// CodeGear C++Builder
// Copyright (c) 1995, 2015 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'libavutil.pas' rev: 30.00 (Windows)

#ifndef LibavutilHPP
#define LibavutilHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member 
#pragma pack(push,8)
#include <System.hpp>
#include <SysInit.hpp>
#include <ffmpeg_types.hpp>

//-- user supplied -----------------------------------------------------------

namespace Libavutil
{
//-- forward type declarations -----------------------------------------------
struct FF_PAD_STRUCTURE_AVBPrint;
struct AVBPrint;
struct AVDictionaryEntry;
struct DECLSPEC_DRECORD AVDictionary
{
};


struct DECLSPEC_DRECORD AVBuffer
{
};


struct AVBufferRef;
struct DECLSPEC_DRECORD AVBufferPool
{
};


struct AVRational;
struct AVFrameSideData;
struct AVRegionOfInterest;
struct AVFrame;
struct FFFrameBucket;
struct FFFrameQueueGlobal;
struct FFFrameQueue;
struct Tdefault_val;
struct AVOption;
struct AVOptionRange;
struct AVOptionRanges;
struct avclass;
struct TErrorItem;
struct DECLSPEC_DRECORD AVAudioFifo
{
};


struct DECLSPEC_DRECORD tm
{
};


struct DECLSPEC_DRECORD AVExpr
{
};


struct AVFifoBuffer;
struct DECLSPEC_DRECORD AVHWDeviceInternal
{
};


struct AVHWDeviceContext;
struct DECLSPEC_DRECORD AVHWFramesInternal
{
};


struct AVHWFramesContext;
struct AVHWFramesConstraints;
struct AVMediaCodecDeviceContext;
struct AVDRMObjectDescriptor;
struct AVDRMPlaneDescriptor;
struct AVDRMLayerDescriptor;
struct AVDRMFrameDescriptor;
struct AVDRMDeviceContext;
struct AVComponentDescriptor;
struct AVPixFmtDescriptor;
struct DECLSPEC_DRECORD Tav_read_array4_puint8_t
{
};


struct DECLSPEC_DRECORD Tav_read_array4_int
{
};


struct AVTimecode;
struct AVMotionVector;
struct DECLSPEC_DRECORD AVMD5
{
};


struct av_intfloat32;
struct av_intfloat64;
struct AVMasteringDisplayMetadata;
struct AVContentLightMetadata;
struct DECLSPEC_DRECORD AVAES
{
};


struct DECLSPEC_DRECORD AVTWOFISH
{
};


struct DECLSPEC_DRECORD AVTEA
{
};


struct DECLSPEC_DRECORD AVTXContext
{
};


struct AVComplexFloat;
struct AVLFG;
//-- type declarations -------------------------------------------------------
struct DECLSPEC_DRECORD FF_PAD_STRUCTURE_AVBPrint
{
public:
	char *str;
	unsigned len;
	unsigned size;
	unsigned size_max;
	System::StaticArray<char, 1> reserved_internal_buffer;
};


typedef AVBPrint *pAVBPrint;

struct DECLSPEC_DRECORD AVBPrint
{
public:
	char *str;
	unsigned len;
	unsigned size;
	unsigned size_max;
	System::StaticArray<char, 1> reserved_internal_buffer;
	System::StaticArray<char, 1004> reserved_padding;
};


enum DECLSPEC_DENUM AVMatrixEncoding : unsigned int { AV_MATRIX_ENCODING_NONE, AV_MATRIX_ENCODING_DOLBY, AV_MATRIX_ENCODING_DPLII, AV_MATRIX_ENCODING_DPLIIX, AV_MATRIX_ENCODING_DPLIIZ, AV_MATRIX_ENCODING_DOLBYEX, AV_MATRIX_ENCODING_DOLBYHEADPHONE, AV_MATRIX_ENCODING_NB };

struct DECLSPEC_DRECORD AVDictionaryEntry
{
public:
	char *key;
	char *value;
};


typedef AVDictionaryEntry *pAVDictionaryEntry;

typedef AVDictionary *pAVDictionary;

typedef pAVDictionary *ppAVDictionary;

typedef AVBuffer *pAVBuffer;

struct DECLSPEC_DRECORD AVBufferRef
{
public:
	AVBuffer *buffer;
	System::Byte *data;
	int size;
};


typedef AVBufferRef *pAVBufferRef;

typedef pAVBufferRef *ppAVBufferRef;

typedef void __cdecl (*TFreeProc)(void * opaque, System::PByte data);

typedef AVBufferPool *pAVBufferPool;

typedef pAVBufferRef __cdecl (*Tbuffer_pool_init_proc)(int size);

typedef pAVBufferRef __cdecl (*Tav_buffer_pool_init2_alloc_proc)(void * opaque, int size);

typedef void __cdecl (*Tav_buffer_pool_init2_pool_free_proc)(void * opaque);

struct DECLSPEC_DRECORD AVRational
{
public:
	int num;
	int den;
};


typedef AVRational *pAVRational;

enum DECLSPEC_DENUM AVMediaType: int { AVMEDIA_TYPE_UNKNOWN = -1, AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_DATA, AVMEDIA_TYPE_SUBTITLE, AVMEDIA_TYPE_ATTACHMENT, AVMEDIA_TYPE_NB };

enum DECLSPEC_DENUM AVPictureType : unsigned int { AV_PICTURE_TYPE_NONE, AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, AV_PICTURE_TYPE_S, AV_PICTURE_TYPE_SI, AV_PICTURE_TYPE_SP, AV_PICTURE_TYPE_BI };

enum DECLSPEC_DENUM AVPixelFormat: int { AV_PIX_FMT_NONE = -1, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUYV422, AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_GRAY8, AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_PAL8, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_UYVY422, AV_PIX_FMT_UYYVYY411, AV_PIX_FMT_BGR8, AV_PIX_FMT_BGR4, AV_PIX_FMT_BGR4_BYTE, AV_PIX_FMT_RGB8, AV_PIX_FMT_RGB4, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_NV12, AV_PIX_FMT_NV21, AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGB48LE, 
	AV_PIX_FMT_RGB565BE, AV_PIX_FMT_RGB565LE, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_RGB555LE, AV_PIX_FMT_BGR565BE, AV_PIX_FMT_BGR565LE, AV_PIX_FMT_BGR555BE, AV_PIX_FMT_BGR555LE, AV_PIX_FMT_VAAPI_MOCO, AV_PIX_FMT_VAAPI_IDCT, AV_PIX_FMT_VAAPI_VLD, AV_PIX_FMT_VAAPI = 46, AV_PIX_FMT_YUV420P16LE, AV_PIX_FMT_YUV420P16BE, AV_PIX_FMT_YUV422P16LE, AV_PIX_FMT_YUV422P16BE, AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUV444P16BE, AV_PIX_FMT_DXVA2_VLD, AV_PIX_FMT_RGB444LE, AV_PIX_FMT_RGB444BE, AV_PIX_FMT_BGR444LE, AV_PIX_FMT_BGR444BE, AV_PIX_FMT_YA8, AV_PIX_FMT_Y400A = 58, AV_PIX_FMT_GRAY8A = 58, AV_PIX_FMT_BGR48BE, AV_PIX_FMT_BGR48LE, AV_PIX_FMT_YUV420P9BE, AV_PIX_FMT_YUV420P9LE, AV_PIX_FMT_YUV420P10BE, AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUV422P10BE, AV_PIX_FMT_YUV422P10LE, 
	AV_PIX_FMT_YUV444P9BE, AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUV444P10BE, AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUV422P9BE, AV_PIX_FMT_YUV422P9LE, AV_PIX_FMT_VDA_VLD, AV_PIX_FMT_GBRP, AV_PIX_FMT_GBR24P = 74, AV_PIX_FMT_GBRP9BE, AV_PIX_FMT_GBRP9LE, AV_PIX_FMT_GBRP10BE, AV_PIX_FMT_GBRP10LE, AV_PIX_FMT_GBRP16BE, AV_PIX_FMT_GBRP16LE, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA420P9BE, AV_PIX_FMT_YUVA420P9LE, AV_PIX_FMT_YUVA422P9BE, AV_PIX_FMT_YUVA422P9LE, AV_PIX_FMT_YUVA444P9BE, AV_PIX_FMT_YUVA444P9LE, AV_PIX_FMT_YUVA420P10BE, AV_PIX_FMT_YUVA420P10LE, AV_PIX_FMT_YUVA422P10BE, AV_PIX_FMT_YUVA422P10LE, AV_PIX_FMT_YUVA444P10BE, AV_PIX_FMT_YUVA444P10LE, AV_PIX_FMT_YUVA420P16BE, AV_PIX_FMT_YUVA420P16LE, AV_PIX_FMT_YUVA422P16BE, AV_PIX_FMT_YUVA422P16LE, 
	AV_PIX_FMT_YUVA444P16BE, AV_PIX_FMT_YUVA444P16LE, AV_PIX_FMT_VDPAU, AV_PIX_FMT_XYZ12LE, AV_PIX_FMT_XYZ12BE, AV_PIX_FMT_NV16, AV_PIX_FMT_NV20LE, AV_PIX_FMT_NV20BE, AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_BGRA64BE, AV_PIX_FMT_BGRA64LE, AV_PIX_FMT_YVYU422, AV_PIX_FMT_VDA, AV_PIX_FMT_YA16BE, AV_PIX_FMT_YA16LE, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP16BE, AV_PIX_FMT_GBRAP16LE, AV_PIX_FMT_QSV, AV_PIX_FMT_MMAL, AV_PIX_FMT_D3D11VA_VLD, AV_PIX_FMT_CUDA, AV_PIX_FMT_0RGB = 295, AV_PIX_FMT_RGB0, AV_PIX_FMT_0BGR, AV_PIX_FMT_BGR0, AV_PIX_FMT_YUV420P12BE, AV_PIX_FMT_YUV420P12LE, AV_PIX_FMT_YUV420P14BE, AV_PIX_FMT_YUV420P14LE, AV_PIX_FMT_YUV422P12BE, AV_PIX_FMT_YUV422P12LE, AV_PIX_FMT_YUV422P14BE, AV_PIX_FMT_YUV422P14LE, AV_PIX_FMT_YUV444P12BE, 
	AV_PIX_FMT_YUV444P12LE, AV_PIX_FMT_YUV444P14BE, AV_PIX_FMT_YUV444P14LE, AV_PIX_FMT_GBRP12BE, AV_PIX_FMT_GBRP12LE, AV_PIX_FMT_GBRP14BE, AV_PIX_FMT_GBRP14LE, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_BAYER_BGGR8, AV_PIX_FMT_BAYER_RGGB8, AV_PIX_FMT_BAYER_GBRG8, AV_PIX_FMT_BAYER_GRBG8, AV_PIX_FMT_BAYER_BGGR16LE, AV_PIX_FMT_BAYER_BGGR16BE, AV_PIX_FMT_BAYER_RGGB16LE, AV_PIX_FMT_BAYER_RGGB16BE, AV_PIX_FMT_BAYER_GBRG16LE, AV_PIX_FMT_BAYER_GBRG16BE, AV_PIX_FMT_BAYER_GRBG16LE, AV_PIX_FMT_BAYER_GRBG16BE, AV_PIX_FMT_XVMC, AV_PIX_FMT_YUV440P10LE, AV_PIX_FMT_YUV440P10BE, AV_PIX_FMT_YUV440P12LE, AV_PIX_FMT_YUV440P12BE, AV_PIX_FMT_AYUV64LE, AV_PIX_FMT_AYUV64BE, AV_PIX_FMT_VIDEOTOOLBOX, AV_PIX_FMT_P010LE, AV_PIX_FMT_P010BE, AV_PIX_FMT_GBRAP12BE, AV_PIX_FMT_GBRAP12LE, 
	AV_PIX_FMT_GBRAP10BE, AV_PIX_FMT_GBRAP10LE, AV_PIX_FMT_MEDIACODEC, AV_PIX_FMT_GRAY12BE, AV_PIX_FMT_GRAY12LE, AV_PIX_FMT_GRAY10BE, AV_PIX_FMT_GRAY10LE, AV_PIX_FMT_P016LE, AV_PIX_FMT_P016BE, AV_PIX_FMT_D3D11, AV_PIX_FMT_GRAY9BE, AV_PIX_FMT_GRAY9LE, AV_PIX_FMT_GBRPF32BE, AV_PIX_FMT_GBRPF32LE, AV_PIX_FMT_GBRAPF32BE, AV_PIX_FMT_GBRAPF32LE, AV_PIX_FMT_DRM_PRIME, AV_PIX_FMT_OPENCL, AV_PIX_FMT_GRAY14BE, AV_PIX_FMT_GRAY14LE, AV_PIX_FMT_GRAYF32BE, AV_PIX_FMT_GRAYF32LE, AV_PIX_FMT_YUVA422P12BE, AV_PIX_FMT_YUVA422P12LE, AV_PIX_FMT_YUVA444P12BE, AV_PIX_FMT_YUVA444P12LE, AV_PIX_FMT_NV24, AV_PIX_FMT_NV42, AV_PIX_FMT_NB };

typedef AVPixelFormat *pAVPixelFormat;

enum DECLSPEC_DENUM AVColorPrimaries : unsigned int { AVCOL_PRI_RESERVED0, AVCOL_PRI_BT709, AVCOL_PRI_UNSPECIFIED, AVCOL_PRI_RESERVED, AVCOL_PRI_BT470M, AVCOL_PRI_BT470BG, AVCOL_PRI_SMPTE170M, AVCOL_PRI_SMPTE240M, AVCOL_PRI_FILM, AVCOL_PRI_BT2020, AVCOL_PRI_SMPTE428, AVCOL_PRI_SMPTEST428_1 = 10, AVCOL_PRI_SMPTE431, AVCOL_PRI_SMPTE432, AVCOL_PRI_JEDEC_P22 = 22, AVCOL_PRI_NB };

enum DECLSPEC_DENUM AVColorTransferCharacteristic : unsigned int { AVCOL_TRC_RESERVED0, AVCOL_TRC_BT709, AVCOL_TRC_UNSPECIFIED, AVCOL_TRC_RESERVED, AVCOL_TRC_GAMMA22, AVCOL_TRC_GAMMA28, AVCOL_TRC_SMPTE170M, AVCOL_TRC_SMPTE240M, AVCOL_TRC_LINEAR, AVCOL_TRC_LOG, AVCOL_TRC_LOG_SQRT, AVCOL_TRC_IEC61966_2_4, AVCOL_TRC_BT1361_ECG, AVCOL_TRC_IEC61966_2_1, AVCOL_TRC_BT2020_10, AVCOL_TRC_BT2020_12, AVCOL_TRC_SMPTE2084, AVCOL_TRC_SMPTEST2084 = 16, AVCOL_TRC_SMPTE428, AVCOL_TRC_SMPTEST428_1 = 17, AVCOL_TRC_ARIB_STD_B67, AVCOL_TRC_NB };

enum DECLSPEC_DENUM AVColorSpace : unsigned int { AVCOL_SPC_RGB, AVCOL_SPC_BT709, AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_RESERVED, AVCOL_SPC_FCC, AVCOL_SPC_BT470BG, AVCOL_SPC_SMPTE170M, AVCOL_SPC_SMPTE240M, AVCOL_SPC_YCGCO, AVCOL_SPC_YCOCG = 8, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_BT2020_CL, AVCOL_SPC_SMPTE2085, AVCOL_SPC_NB };

enum DECLSPEC_DENUM AVColorRange : unsigned int { AVCOL_RANGE_UNSPECIFIED, AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG, AVCOL_RANGE_NB };

enum DECLSPEC_DENUM AVChromaLocation : unsigned int { AVCHROMA_LOC_UNSPECIFIED, AVCHROMA_LOC_LEFT, AVCHROMA_LOC_CENTER, AVCHROMA_LOC_TOPLEFT, AVCHROMA_LOC_TOP, AVCHROMA_LOC_BOTTOMLEFT, AVCHROMA_LOC_BOTTOM, AVCHROMA_LOC_NB };

typedef System::StaticArray<int, 8> TAVNDPArray;

typedef TAVNDPArray *pAVNDPArray;

typedef TAVNDPArray TAVNDPArray_int;

typedef TAVNDPArray *pAVNDPArray_int;

typedef System::StaticArray<System::PByte, 8> TAVNDPArray_puint8_t;

typedef TAVNDPArray_puint8_t *pAVNDPArray_puint8_t;

typedef System::StaticArray<unsigned __int64, 8> TAVNDPArray_uint64_t;

typedef System::StaticArray<pAVBufferRef, 8> TAVNDPArray_pAVBufferRef;

typedef TAVNDPArray_pAVBufferRef *pAVNDPArray_pAVBufferRef;

typedef System::StaticArray<System::Byte, 4> Tuint8_t_array_4;

typedef Tuint8_t_array_4 *puint8_t_array_4;

typedef System::StaticArray<int, 4> Tint_array_4;

enum DECLSPEC_DENUM AVFrameSideDataType : unsigned int { AV_FRAME_DATA_PANSCAN, AV_FRAME_DATA_A53_CC, AV_FRAME_DATA_STEREO3D, AV_FRAME_DATA_MATRIXENCODING, AV_FRAME_DATA_DOWNMIX_INFO, AV_FRAME_DATA_REPLAYGAIN, AV_FRAME_DATA_DISPLAYMATRIX, AV_FRAME_DATA_AFD, AV_FRAME_DATA_MOTION_VECTORS, AV_FRAME_DATA_SKIP_SAMPLES, AV_FRAME_DATA_AUDIO_SERVICE_TYPE, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_GOP_TIMECODE, AV_FRAME_DATA_SPHERICAL, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL, AV_FRAME_DATA_ICC_PROFILE, AV_FRAME_DATA_QP_TABLE_PROPERTIES, AV_FRAME_DATA_QP_TABLE_DATA, AV_FRAME_DATA_S12M_TIMECODE, AV_FRAME_DATA_DYNAMIC_HDR_PLUS, AV_FRAME_DATA_REGIONS_OF_INTEREST };

enum DECLSPEC_DENUM AVActiveFormatDescription : unsigned int { AV_AFD_SAME = 8, AV_AFD_4_3, AV_AFD_16_9, AV_AFD_14_9, AV_AFD_4_3_SP_14_9 = 13, AV_AFD_16_9_SP_14_9, AV_AFD_SP_4_3 };

struct DECLSPEC_DRECORD AVFrameSideData
{
public:
	AVFrameSideDataType _type;
	System::Byte *data;
	int size;
	AVDictionary *metadata;
	AVBufferRef *buf;
};


typedef AVFrameSideData *pAVFrameSideData;

typedef pAVFrameSideData *ppAVFrameSideData;

struct DECLSPEC_DRECORD AVRegionOfInterest
{
public:
	unsigned self_size;
	int top;
	int bottom;
	int left;
	int right;
	AVRational qoffset;
};


typedef AVRegionOfInterest *pAVRegionOfInterest;

typedef AVFrame *pAVFrame;

struct DECLSPEC_DRECORD AVFrame
{
public:
	TAVNDPArray_puint8_t data;
	TAVNDPArray linesize;
	System::PByte *extended_data;
	int width;
	int height;
	int nb_samples;
	int format;
	int key_frame;
	AVPictureType pict_type;
	AVRational sample_aspect_ratio;
	__int64 pts;
	__int64 pkt_pts;
	__int64 pkt_dts;
	int coded_picture_number;
	int display_picture_number;
	int quality;
	void *opaque;
	TAVNDPArray_puint8_t error;
	int repeat_pict;
	int interlaced_frame;
	int top_field_first;
	int palette_has_changed;
	__int64 reordered_opaque;
	int sample_rate;
	unsigned __int64 channel_layout;
	TAVNDPArray_pAVBufferRef buf;
	pAVBufferRef *extended_buf;
	int nb_extended_buf;
	pAVFrameSideData *side_data;
	int nb_side_data;
	int flags;
	AVColorRange color_range;
	AVColorPrimaries color_primaries;
	AVColorTransferCharacteristic color_trc;
	AVColorSpace colorspace;
	AVChromaLocation chroma_location;
	__int64 best_effort_timestamp;
	__int64 pkt_pos;
	__int64 pkt_duration;
	AVDictionary *metadata;
	int decode_error_flags;
	int channels;
	int pkt_size;
	System::Int8 *qscale_table;
	int qstride;
	int qscale_type;
	AVBufferRef *qp_table_buf;
	AVBufferRef *hw_frames_ctx;
	AVBufferRef *opaque_ref;
	NativeUInt crop_top;
	NativeUInt crop_bottom;
	NativeUInt crop_left;
	NativeUInt crop_right;
	AVBufferRef *private_ref;
};


typedef FFFrameBucket *pFFFrameBucket;

struct DECLSPEC_DRECORD FFFrameBucket
{
public:
	AVFrame *frame;
};


typedef FFFrameQueueGlobal *pFFFrameQueueGlobal;

struct DECLSPEC_DRECORD FFFrameQueueGlobal
{
public:
	char dummy;
};


typedef FFFrameQueue *pFFFrameQueue;

struct DECLSPEC_DRECORD FFFrameQueue
{
public:
	FFFrameBucket *queue;
	NativeUInt allocated;
	NativeUInt tail;
	NativeUInt queued;
	FFFrameBucket first_bucket;
	unsigned __int64 total_frames_head;
	unsigned __int64 total_frames_tail;
	unsigned __int64 total_samples_head;
	unsigned __int64 total_samples_tail;
	int samples_skipped;
};


enum DECLSPEC_DENUM AVOptionType : unsigned int { AV_OPT_TYPE_FLAGS, AV_OPT_TYPE_INT, AV_OPT_TYPE_INT64, AV_OPT_TYPE_DOUBLE, AV_OPT_TYPE_FLOAT, AV_OPT_TYPE_STRING, AV_OPT_TYPE_RATIONAL, AV_OPT_TYPE_BINARY, AV_OPT_TYPE_DICT, AV_OPT_TYPE_UINT64, AV_OPT_TYPE_CONST, AV_OPT_TYPE_IMAGE_SIZE, AV_OPT_TYPE_PIXEL_FMT, AV_OPT_TYPE_SAMPLE_FMT, AV_OPT_TYPE_VIDEO_RATE, AV_OPT_TYPE_DURATION, AV_OPT_TYPE_COLOR, AV_OPT_TYPE_CHANNEL_LAYOUT, AV_OPT_TYPE_BOOL };

struct DECLSPEC_DRECORD Tdefault_val
{
	
public:
	union
	{
		struct 
		{
			AVRational q;
		};
		struct 
		{
			char *str;
		};
		struct 
		{
			double dbl;
		};
		struct 
		{
			__int64 i64;
		};
		
	};
};


struct DECLSPEC_DRECORD AVOption
{
public:
	char *name;
	char *help;
	int offset;
	AVOptionType _type;
	Tdefault_val default_val;
	double min;
	double max;
	int flags;
	char *_unit;
};


typedef AVOption *pAVOption;

struct DECLSPEC_DRECORD AVOptionRange
{
public:
	char *str;
	double value_min;
	double value_max;
	double component_min;
	double component_max;
	int is_range;
};


typedef AVOptionRange *pAVOptionRange;

typedef pAVOptionRange *ppAVOptionRange;

struct DECLSPEC_DRECORD AVOptionRanges
{
public:
	pAVOptionRange *range;
	int nb_ranges;
	int nb_components;
};


typedef AVOptionRanges *pAVOptionRanges;

enum DECLSPEC_DENUM AVClassCategory : unsigned int { AV_CLASS_CATEGORY_NA, AV_CLASS_CATEGORY_INPUT, AV_CLASS_CATEGORY_OUTPUT, AV_CLASS_CATEGORY_MUXER, AV_CLASS_CATEGORY_DEMUXER, AV_CLASS_CATEGORY_ENCODER, AV_CLASS_CATEGORY_DECODER, AV_CLASS_CATEGORY_FILTER, AV_CLASS_CATEGORY_BITSTREAM_FILTER, AV_CLASS_CATEGORY_SWSCALER, AV_CLASS_CATEGORY_SWRESAMPLER, AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40, AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT, AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT, AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT, AV_CLASS_CATEGORY_DEVICE_OUTPUT, AV_CLASS_CATEGORY_DEVICE_INPUT, AV_CLASS_CATEGORY_NB };

typedef AVClassCategory *pAVClassCategory;

typedef avclass *pAVClass;

struct DECLSPEC_DRECORD avclass
{
public:
	char *class_name;
	char * __cdecl (*item_name)(void * ctx);
	AVOption *option;
	int version;
	int log_level_offset_offset;
	int parent_log_context_offset;
	void * __cdecl (*child_next)(void * obj, void * prev);
	pAVClass __cdecl (*child_class_next)(const pAVClass prev);
	AVClassCategory category;
	pAVClassCategory __cdecl (*get_category)(void * ctx);
	int __cdecl (*query_ranges)(pAVOptionRanges &ranges, void * obj, const char * key, int flags);
};


typedef System::StaticArray<void *, 1> VA_LIST;

typedef VA_LIST *PVA_LIST;

enum DECLSPEC_DENUM AVSampleFormat: int { AV_SAMPLE_FMT_NONE = -1, AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64P, AV_SAMPLE_FMT_NB };

typedef AVSampleFormat *pAVSampleFormat;

typedef void __cdecl (*Tav_log_callback)(void * p, int lvl, char * fmt, PVA_LIST vl);

struct DECLSPEC_DRECORD TErrorItem
{
public:
	int err;
	System::UnicodeString msg;
};


typedef System::StaticArray<TErrorItem, 174> Libavutil__1;

typedef AVAudioFifo *pAVAudioFifo;

enum DECLSPEC_DENUM AVEscapeMode : unsigned int { AV_ESCAPE_MODE_AUTO, AV_ESCAPE_MODE_BACKSLASH, AV_ESCAPE_MODE_QUOTE };

typedef tm *ptm;

typedef System::StaticArray<int, 9> Tav_display_matrix;

typedef AVExpr *pAVExpr;

typedef Ffmpeg_types::ppDouble __cdecl (*Tav_expr_funcs1)(void * p1, double p2);

typedef Ffmpeg_types::ppDouble __cdecl (*Tav_expr_funcs2)(void * p1, double p2, double p3);

typedef AVFifoBuffer *pAVFifoBuffer;

struct DECLSPEC_DRECORD AVFifoBuffer
{
public:
	System::Byte *buffer;
	System::Byte *rptr;
	System::Byte *wptr;
	System::Byte *_end;
	unsigned rndx;
	unsigned wndx;
};


typedef void __cdecl (*Tav_fifo_proc)(void * p1, void * p2, int p3);

typedef int __cdecl (*Tav_fifo_func)(void * p1, void * p2, int p3);

enum DECLSPEC_DENUM AVHWDeviceType : unsigned int { AV_HWDEVICE_TYPE_NONE, AV_HWDEVICE_TYPE_VDPAU, AV_HWDEVICE_TYPE_CUDA, AV_HWDEVICE_TYPE_VAAPI, AV_HWDEVICE_TYPE_DXVA2, AV_HWDEVICE_TYPE_QSV, AV_HWDEVICE_TYPE_VIDEOTOOLBOX, AV_HWDEVICE_TYPE_D3D11VA, AV_HWDEVICE_TYPE_DRM, AV_HWDEVICE_TYPE_OPENCL, AV_HWDEVICE_TYPE_MEDIACODEC };

typedef AVHWDeviceInternal *pAVHWDeviceInternal;

typedef AVHWDeviceContext *pAVHWDeviceContext;

struct DECLSPEC_DRECORD AVHWDeviceContext
{
public:
	avclass *av_class;
	AVHWDeviceInternal *internal;
	AVHWDeviceType _type;
	void *hwctx;
	void __cdecl (*free)(pAVHWDeviceContext ctx);
	void *user_opaque;
};


typedef AVHWFramesInternal *pAVHWFramesInternal;

typedef AVHWFramesContext *pAVHWFramesContext;

struct DECLSPEC_DRECORD AVHWFramesContext
{
public:
	avclass *av_class;
	AVHWFramesInternal *internal;
	AVBufferRef *device_ref;
	AVHWDeviceContext *device_ctx;
	void *hwctx;
	void __cdecl (*free)(pAVHWFramesContext ctx);
	void *user_opaque;
	AVBufferPool *pool;
	int initial_pool_size;
	AVPixelFormat format;
	AVPixelFormat sw_format;
	int width;
	int height;
};


enum DECLSPEC_DENUM AVHWFrameTransferDirection : unsigned int { AV_HWFRAME_TRANSFER_DIRECTION_FROM, AV_HWFRAME_TRANSFER_DIRECTION_TO };

typedef AVHWFramesConstraints *pAVHWFramesConstraints;

struct DECLSPEC_DRECORD AVHWFramesConstraints
{
public:
	AVPixelFormat *valid_hw_formats;
	AVPixelFormat *valid_sw_formats;
	int min_width;
	int min_height;
	int max_width;
	int max_height;
};


typedef AVMediaCodecDeviceContext *pAVMediaCodecDeviceContext;

struct DECLSPEC_DRECORD AVMediaCodecDeviceContext
{
public:
	void *surface;
};


typedef AVDRMObjectDescriptor *pAVDRMObjectDescriptor;

struct DECLSPEC_DRECORD AVDRMObjectDescriptor
{
public:
	int fd;
	NativeUInt size;
	unsigned __int64 format_modifier;
};


typedef AVDRMPlaneDescriptor *pAVDRMPlaneDescriptor;

struct DECLSPEC_DRECORD AVDRMPlaneDescriptor
{
public:
	int object_index;
	unsigned offset;
	unsigned pitch;
};


typedef AVDRMLayerDescriptor *pAVDRMLayerDescriptor;

struct DECLSPEC_DRECORD AVDRMLayerDescriptor
{
public:
	unsigned format;
	int nb_planes;
	System::StaticArray<AVDRMPlaneDescriptor, 4> planes;
};


typedef AVDRMFrameDescriptor *pAVDRMFrameDescriptor;

struct DECLSPEC_DRECORD AVDRMFrameDescriptor
{
public:
	int nb_objects;
	System::StaticArray<AVDRMObjectDescriptor, 4> objects;
	int nb_layers;
	System::StaticArray<AVDRMLayerDescriptor, 4> layers;
};


typedef AVDRMDeviceContext *pAVDRMDeviceContext;

struct DECLSPEC_DRECORD AVDRMDeviceContext
{
public:
	int fd;
};


typedef AVComponentDescriptor *pAVComponentDescriptor;

struct DECLSPEC_DRECORD AVComponentDescriptor
{
public:
	int plane;
	int step;
	int offset;
	int shift;
	int depth;
	int step_minus1 _DEPRECATED_ATTRIBUTE0 ;
	int depth_minus1 _DEPRECATED_ATTRIBUTE0 ;
	int offset_plus1 _DEPRECATED_ATTRIBUTE0 ;
};


typedef AVPixFmtDescriptor *pAVPixFmtDescriptor;

struct DECLSPEC_DRECORD AVPixFmtDescriptor
{
public:
	char *name;
	System::Byte nb_components;
	System::Byte log2_chroma_w;
	System::Byte log2_chroma_h;
	unsigned __int64 flags;
	System::StaticArray<AVComponentDescriptor, 4> comp;
	char *alias;
};


typedef Tav_read_array4_puint8_t *pav_read_array4_puint8_t;

typedef Tav_read_array4_int *pav_read_array4_int;

typedef Ffmpeg_types::array4_int Tav_image_array4_int;

typedef Ffmpeg_types::array4_int *pav_image_array4_int;

typedef Ffmpeg_types::array4_puint8_t Tav_image_array4_puint8_t;

typedef Ffmpeg_types::array4_puint8_t *pav_image_array4_puint8_t;

typedef Ffmpeg_types::array4_ptrdiff_t Tav_image_array4_ptrdiff_t;

typedef Ffmpeg_types::array4_ptrdiff_t *pav_image_array4_ptrdiff_t;

enum DECLSPEC_DENUM AVTimecodeFlag : unsigned int { AV_TIMECODE_FLAG_DROPFRAME = 0x1, AV_TIMECODE_FLAG_24HOURSMAX, AV_TIMECODE_FLAG_ALLOWNEGATIVE = 0x4 };

typedef AVTimecode *pAVTimecode;

struct DECLSPEC_DRECORD AVTimecode
{
public:
	int start;
	unsigned flags;
	AVRational rate;
	unsigned fps;
};


typedef int AVRounding;

typedef AVMotionVector *pAVMotionVector;

struct DECLSPEC_DRECORD AVMotionVector
{
public:
	int source;
	System::Byte w;
	System::Byte h;
	short src_x;
	short src_y;
	short dst_x;
	short dst_y;
	unsigned __int64 flags;
	int motion_x;
	int motion_y;
	System::Word motion_scale;
};


typedef AVMD5 *pAVMD5;

struct DECLSPEC_DRECORD av_intfloat32
{
	
public:
	union
	{
		struct 
		{
			float f;
		};
		struct 
		{
			unsigned i;
		};
		
	};
};


struct DECLSPEC_DRECORD av_intfloat64
{
	
public:
	union
	{
		struct 
		{
			double f;
		};
		struct 
		{
			unsigned __int64 i;
		};
		
	};
};


typedef AVMasteringDisplayMetadata *pAVMasteringDisplayMetadata;

struct DECLSPEC_DRECORD AVMasteringDisplayMetadata
{
public:
	System::StaticArray<System::StaticArray<AVRational, 2>, 3> display_primaries;
	System::StaticArray<AVRational, 2> white_point;
	AVRational min_luminance;
	AVRational max_luminance;
	int has_primaries;
	int has_luminance;
};


typedef AVContentLightMetadata *pAVContentLightMetadata;

struct DECLSPEC_DRECORD AVContentLightMetadata
{
public:
	unsigned MaxCLL;
	unsigned MaxFALL;
};


typedef int __cdecl (*av_pixelutils_sad_fn)(const System::PByte src1, unsigned stride1, const System::PByte src2, unsigned stride2);

typedef AVAES *pAVAES;

typedef AVTWOFISH *pAVTWOFISH;

typedef AVTEA *pAVTEA;

typedef AVTXContext *pAVTXContext;

struct DECLSPEC_DRECORD AVComplexFloat
{
public:
	float re;
	float im;
};


enum DECLSPEC_DENUM AVTXType : unsigned int { AV_TX_FLOAT_FFT, AV_TX_FLOAT_MDCT };

typedef void __cdecl (*av_tx_fn)(pAVTXContext s, void * out, void * in, unsigned stride);

typedef AVLFG *pAVLFG;

struct DECLSPEC_DRECORD AVLFG
{
public:
	System::StaticArray<unsigned, 64> state;
	int index;
};


typedef System::StaticArray<double, 2> Tav_bmg_get_arrayofdouble;

//-- var, const, procedure ---------------------------------------------------
static const System::Int8 LIBAVUTIL_VERSION_MAJOR = System::Int8(0x38);
#define LIBAVUTIL_VERSION_MAJOR_STR L"56"
static const System::Int8 LIBAVUTIL_VERSION_MINOR = System::Int8(0x1f);
static const System::Int8 LIBAVUTIL_VERSION_MICRO = System::Int8(0x64);
#define FFMPEG_VERSION L"4.2.2"
static const int LIBAVUTIL_VERSION_INT = int(0x381f64);
static const System::Int8 LIBSWSCALE_VERSION_MAJOR = System::Int8(0x5);
static const System::WideChar LIBSWSCALE_VERSION_MAJOR_STR = (System::WideChar)(0x35);
static const System::Int8 LIBSWSCALE_VERSION_MINOR = System::Int8(0x5);
static const System::Int8 LIBSWSCALE_VERSION_MICRO = System::Int8(0x64);
static const System::Int8 LIBAVCODEC_VERSION_MAJOR = System::Int8(0x3a);
#define LIBAVCODEC_VERSION_MAJOR_STR L"58"
static const System::Int8 LIBAVCODEC_VERSION_MINOR = System::Int8(0x36);
static const System::Int8 LIBAVCODEC_VERSION_MICRO = System::Int8(0x64);
static const System::Int8 LIBAVDEVICE_VERSION_MAJOR = System::Int8(0x3a);
#define LIBAVDEVICE_VERSION_MAJOR_STR L"58"
static const System::Int8 LIBAVDEVICE_VERSION_MINOR = System::Int8(0x8);
static const System::Int8 LIBAVDEVICE_VERSION_MICRO = System::Int8(0x64);
static const System::Int8 LIBAVFORMAT_VERSION_MAJOR = System::Int8(0x3a);
#define LIBAVFORMAT_VERSION_MAJOR_STR L"58"
static const System::Int8 LIBAVFORMAT_VERSION_MINOR = System::Int8(0x1d);
static const System::Int8 LIBAVFORMAT_VERSION_MICRO = System::Int8(0x64);
static const System::Int8 FF_API_R_FRAME_RATE = System::Int8(0x1);
static const System::Int8 LIBPOSTPROC_VERSION_MAJOR = System::Int8(0x37);
#define LIBPOSTPROC_VERSION_MAJOR_STR L"55"
static const System::Int8 LIBPOSTPROC_VERSION_MINOR = System::Int8(0x5);
static const System::Int8 LIBPOSTPROC_VERSION_MICRO = System::Int8(0x64);
static const System::Int8 LIBSWRESAMPLE_VERSION_MAJOR = System::Int8(0x3);
static const System::WideChar LIBSWRESAMPLE_VERSION_MAJOR_STR = (System::WideChar)(0x33);
static const System::Int8 LIBSWRESAMPLE_VERSION_MINOR = System::Int8(0x5);
static const System::Int8 LIBSWRESAMPLE_VERSION_MICRO = System::Int8(0x64);
static const System::Int8 LIBAVFILTER_VERSION_MAJOR = System::Int8(0x7);
static const System::WideChar LIBAVFILTER_VERSION_MAJOR_STR = (System::WideChar)(0x37);
static const System::Int8 LIBAVFILTER_VERSION_MINOR = System::Int8(0x39);
static const System::Int8 LIBAVFILTER_VERSION_MICRO = System::Int8(0x64);
#define swscale_dll L"swscale-5.dll"
#define avutil_dll L"avutil-56.dll"
#define avcodec_dll L"avcodec-58.dll"
#define avdevice_dll L"avdevice-58.dll"
#define avformat_dll L"avformat-58.dll"
#define postproc_dll L"postproc-55.dll"
#define swresample_dll L"swresample-3.dll"
#define avfilter_dll L"avfilter-7.dll"
static const System::Int8 AV_HAVE_BIGENDIAN = System::Int8(0x0);
static const System::Int8 AV_HAVE_FAST_UNALIGNED = System::Int8(0x1);
extern "C" int __cdecl av_log2(unsigned v);
extern "C" int __cdecl av_log2_16bit(unsigned v);
static const System::Int8 AV_CH_FRONT_LEFT = System::Int8(0x1);
static const System::Int8 AV_CH_FRONT_RIGHT = System::Int8(0x2);
static const System::Int8 AV_CH_FRONT_CENTER = System::Int8(0x4);
static const System::Int8 AV_CH_LOW_FREQUENCY = System::Int8(0x8);
static const System::Int8 AV_CH_BACK_LEFT = System::Int8(0x10);
static const System::Int8 AV_CH_BACK_RIGHT = System::Int8(0x20);
static const System::Int8 AV_CH_FRONT_LEFT_OF_CENTER = System::Int8(0x40);
static const System::Byte AV_CH_FRONT_RIGHT_OF_CENTER = System::Byte(0x80);
static const System::Word AV_CH_BACK_CENTER = System::Word(0x100);
static const System::Word AV_CH_SIDE_LEFT = System::Word(0x200);
static const System::Word AV_CH_SIDE_RIGHT = System::Word(0x400);
static const System::Word AV_CH_TOP_CENTER = System::Word(0x800);
static const System::Word AV_CH_TOP_FRONT_LEFT = System::Word(0x1000);
static const System::Word AV_CH_TOP_FRONT_CENTER = System::Word(0x2000);
static const System::Word AV_CH_TOP_FRONT_RIGHT = System::Word(0x4000);
static const System::Word AV_CH_TOP_BACK_LEFT = System::Word(0x8000);
static const int AV_CH_TOP_BACK_CENTER = int(0x10000);
static const int AV_CH_TOP_BACK_RIGHT = int(0x20000);
static const int AV_CH_STEREO_LEFT = int(0x20000000);
static const int AV_CH_STEREO_RIGHT = int(0x40000000);
static const unsigned AV_CH_WIDE_LEFT = unsigned(0x80000000);
static const __int64 AV_CH_WIDE_RIGHT = 0x0000000100000000LL;
static const __int64 AV_CH_SURROUND_DIRECT_LEFT = 0x0000000200000000LL;
static const __int64 AV_CH_SURROUND_DIRECT_RIGHT = 0x0000000400000000LL;
static const __int64 AV_CH_LOW_FREQUENCY_2 = 0x0000000800000000LL;
static const unsigned __int64 AV_CH_LAYOUT_NATIVE = 0x8000000000000000ULL;
static const System::Int8 AV_CH_LAYOUT_MONO = System::Int8(0x4);
static const System::Int8 AV_CH_LAYOUT_STEREO = System::Int8(0x3);
static const System::Int8 AV_CH_LAYOUT_2POINT1 = System::Int8(0xb);
static const System::Word AV_CH_LAYOUT_2_1 = System::Word(0x103);
static const System::Int8 AV_CH_LAYOUT_SURROUND = System::Int8(0x7);
static const System::Int8 AV_CH_LAYOUT_3POINT1 = System::Int8(0xf);
static const System::Word AV_CH_LAYOUT_4POINT0 = System::Word(0x107);
static const System::Word AV_CH_LAYOUT_4POINT1 = System::Word(0x10f);
static const System::Word AV_CH_LAYOUT_2_2 = System::Word(0x603);
static const System::Int8 AV_CH_LAYOUT_QUAD = System::Int8(0x33);
static const System::Word AV_CH_LAYOUT_5POINT0 = System::Word(0x607);
static const System::Word AV_CH_LAYOUT_5POINT1 = System::Word(0x60f);
static const System::Int8 AV_CH_LAYOUT_5POINT0_BACK = System::Int8(0x37);
static const System::Int8 AV_CH_LAYOUT_5POINT1_BACK = System::Int8(0x3f);
static const System::Word AV_CH_LAYOUT_6POINT0 = System::Word(0x707);
static const System::Word AV_CH_LAYOUT_6POINT0_FRONT = System::Word(0x6c3);
static const System::Word AV_CH_LAYOUT_HEXAGONAL = System::Word(0x137);
static const System::Word AV_CH_LAYOUT_6POINT1 = System::Word(0x70f);
static const System::Word AV_CH_LAYOUT_6POINT1_BACK = System::Word(0x13f);
static const System::Word AV_CH_LAYOUT_6POINT1_FRONT = System::Word(0x6cb);
static const System::Word AV_CH_LAYOUT_7POINT0 = System::Word(0x637);
static const System::Word AV_CH_LAYOUT_7POINT0_FRONT = System::Word(0x6c7);
static const System::Word AV_CH_LAYOUT_7POINT1 = System::Word(0x63f);
static const System::Word AV_CH_LAYOUT_7POINT1_WIDE = System::Word(0x6cf);
static const System::Byte AV_CH_LAYOUT_7POINT1_WIDE_BACK = System::Byte(0xff);
static const System::Word AV_CH_LAYOUT_OCTAGONAL = System::Word(0x737);
static const __int64 AV_CH_LAYOUT_HEXADECAGONAL = 0x000000018003f737LL;
static const int AV_CH_LAYOUT_STEREO_DOWNMIX = int(0x60000000);
extern "C" unsigned __int64 __cdecl av_get_channel_layout(const char * name);
extern "C" int __cdecl av_get_extended_channel_layout(const char * name, unsigned __int64 &channel_layout, int &nb_channels);
extern "C" void __cdecl av_get_channel_layout_string(char * buf, int buf_size, int nb_channels, unsigned __int64 channel_layout);
extern "C" void __cdecl av_bprint_channel_layout(pAVBPrint bp, int nb_channels, unsigned __int64 channel_layout);
extern "C" int __cdecl av_get_channel_layout_nb_channels(unsigned __int64 channel_layout);
extern "C" __int64 __cdecl av_get_default_channel_layout(int nb_channels);
extern "C" int __cdecl av_get_channel_layout_channel_index(unsigned __int64 channel_layout, unsigned __int64 channel);
extern "C" unsigned __int64 __cdecl av_channel_layout_extract_channel(unsigned __int64 channel_layout, int index);
extern "C" char * __cdecl av_get_channel_name(unsigned __int64 channel);
extern "C" char * __cdecl av_get_channel_description(unsigned __int64 channel);
extern "C" int __cdecl av_get_standard_channel_layout(unsigned index, unsigned __int64 &layout, const System::PPAnsiChar name);
static const System::Int8 AV_DICT_MATCH_CASE = System::Int8(0x1);
static const System::Int8 AV_DICT_IGNORE_SUFFIX = System::Int8(0x2);
static const System::Int8 AV_DICT_DONT_STRDUP_KEY = System::Int8(0x4);
static const System::Int8 AV_DICT_DONT_STRDUP_VAL = System::Int8(0x8);
static const System::Int8 AV_DICT_DONT_OVERWRITE = System::Int8(0x10);
static const System::Int8 AV_DICT_APPEND = System::Int8(0x20);
static const System::Int8 AV_DICT_MULTIKEY = System::Int8(0x40);
extern "C" pAVDictionaryEntry __cdecl av_dict_get(const pAVDictionary m, const char * key, const pAVDictionaryEntry prev, int flags);
extern "C" int __cdecl av_dict_count(const pAVDictionary m);
extern "C" int __cdecl av_dict_set(pAVDictionary &pm, const char * key, const char * value, int flags);
extern "C" int __cdecl av_dict_set_int(pAVDictionary &pm, const char * key, __int64 value, int flags);
extern "C" int __cdecl av_dict_parse_string(pAVDictionary &pm, const char * str, const char * key_val_sep, const char * pairs_sep, int flags);
extern "C" int __cdecl av_dict_copy(pAVDictionary &dst, const pAVDictionary src, int flags);
extern "C" void __cdecl av_dict_free(pAVDictionary &m);
extern "C" int __cdecl av_dict_get_string(const pAVDictionary m, char * &buffer, const char key_val_sep, const char pairs_sep);
extern "C" pAVBufferRef __cdecl av_buffer_alloc(int size);
extern "C" pAVBufferRef __cdecl av_buffer_allocz(int size);
static const System::Int8 AV_BUFFER_FLAG_READONLY = System::Int8(0x1);
extern "C" AVBufferRef __cdecl av_buffer_create(System::PByte data, int size, TFreeProc freeproc, void * opaque, int flags);
extern "C" void __cdecl av_buffer_default_free(void * opaque, System::PByte data);
extern "C" pAVBufferRef __cdecl av_buffer_ref(pAVBufferRef buf);
extern "C" void __cdecl av_buffer_unref(pAVBufferRef &buf);
extern "C" int __cdecl av_buffer_is_writable(const pAVBufferRef buf);
extern "C" void * __cdecl av_buffer_get_opaque(const pAVBufferRef buf);
extern "C" int __cdecl av_buffer_get_ref_count(const pAVBufferRef buf);
extern "C" int __cdecl av_buffer_make_writable(pAVBufferRef &buf);
extern "C" int __cdecl av_buffer_realloc(pAVBufferRef &buf, int size);
extern "C" pAVBufferPool __cdecl av_buffer_pool_init(int size, Tbuffer_pool_init_proc alloc);
extern "C" pAVBufferPool __cdecl av_buffer_pool_init2(int size, void * opaque, Tav_buffer_pool_init2_alloc_proc alloc, Tav_buffer_pool_init2_pool_free_proc pool_free);
extern "C" void __cdecl av_buffer_pool_uninit(pAVBufferPool &pool);
extern "C" pAVBufferRef __cdecl av_buffer_pool_get(pAVBufferPool pool);
extern "C" int __cdecl av_reduce(int &dst_num, int &dst_den, __int64 num, __int64 den, __int64 max);
extern "C" AVRational __cdecl av_mul_q(const AVRational b, const AVRational c);
extern "C" AVRational __cdecl av_div_q(const AVRational b, const AVRational c);
extern "C" AVRational __cdecl av_add_q(const AVRational b, const AVRational c);
extern "C" AVRational __cdecl av_sub_q(const AVRational b, const AVRational c);
extern "C" AVRational __cdecl av_d2q(double d, int max);
extern "C" int __cdecl av_nearer_q(const AVRational q, const AVRational q1, const AVRational q2);
extern "C" int __cdecl av_find_nearest_q_idx(const AVRational q, const pAVRational q_list);
extern "C" unsigned __cdecl av_q2intfloat(const AVRational q);
static const System::Int8 FF_LAMBDA_SHIFT = System::Int8(0x7);
static const System::Byte FF_LAMBDA_SCALE = System::Byte(0x80);
static const System::Int8 FF_QP2LAMBDA = System::Int8(0x76);
static const System::Word FF_LAMBDA_MAX = System::Word(0x7fff);
static const System::Byte FF_QUALITY_SCALE = System::Byte(0x80);
static const __int64 AV_NOPTS_VALUE = (-0x7fffffffffffffffLL-1);
static const int AV_TIME_BASE = int(0xf4240);
extern DELPHI_PACKAGE AVRational AV_TIME_BASE_Q;
static const System::Word AVPALETTE_SIZE = System::Word(0x400);
static const System::Word AVPALETTE_COUNT = System::Word(0x100);
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_RGB32;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_RGB32_1;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BGR32;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BGR32_1;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_0RGB32;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_0BGR32;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GRAY10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GRAY12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GRAY16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YA16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_RGB48;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_RGB565;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_RGB555;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_RGB444;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_RGBA64;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BGR48;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BGR565;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BGR555;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BGR444;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BGRA64;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV420P9;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV422P9;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV444P9;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV420P10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV422P10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV440P10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV444P10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV420P12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV422P12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV440P12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV444P12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV420P14;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV422P14;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV444P14;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV420P16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV422P16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUV444P16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRP9;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRP10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRP12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRP14;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRP16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRAP10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRAP12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_GBRAP16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BAYER_BGGR16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BAYER_RGGB16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BAYER_GBRG16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_BAYER_GRBG16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA420P9;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA422P9;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA444P9;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA420P10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA422P10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA444P10;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA422P12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA444P12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA420P16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA422P16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_YUVA444P16;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_XYZ12;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_NV20;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_AYUV64;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_P010;
extern DELPHI_PACKAGE AVPixelFormat AV_PIX_FMT_P016;
static const System::Int8 AV_NUM_DATA_POINTERS = System::Int8(0x8);
static const System::Int8 AV_FRAME_FLAG_CORRUPT = System::Int8(0x1);
static const System::Int8 AV_FRAME_FLAG_DISCARD = System::Int8(0x4);
static const System::Int8 FF_DECODE_ERROR_INVALID_BITSTREAM = System::Int8(0x1);
static const System::Int8 FF_DECODE_ERROR_MISSING_REFERENCE = System::Int8(0x2);
static const System::Int8 FF_DECODE_ERROR_CONCEALMENT_ACTIVE = System::Int8(0x4);
static const System::Int8 FF_DECODE_ERROR_DECODE_SLICES = System::Int8(0x8);
extern "C" __int64 __cdecl av_frame_get_best_effort_timestamp(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_best_effort_timestamp(pAVFrame frame, __int64 val);
extern "C" __int64 __cdecl av_frame_get_pkt_duration(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_pkt_duration(pAVFrame frame, __int64 val);
extern "C" __int64 __cdecl av_frame_get_pkt_pos(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_pkt_pos(pAVFrame frame, __int64 val);
extern "C" __int64 __cdecl av_frame_get_channel_layout(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_channel_layout(pAVFrame frame, __int64 val);
extern "C" int __cdecl av_frame_get_channels(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_channels(pAVFrame frame, int val);
extern "C" int __cdecl av_frame_get_sample_rate(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_sample_rate(pAVFrame frame, int val);
extern "C" pAVDictionary __cdecl av_frame_get_metadata(const AVFrame &frame);
extern "C" void __cdecl av_frame_set_metadata(pAVFrame frame, pAVDictionary val);
extern "C" int __cdecl av_frame_get_decode_error_flags(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_decode_error_flags(pAVFrame frame, int val);
extern "C" int __cdecl av_frame_get_pkt_size(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_pkt_size(const AVFrame frame, int val);
extern "C" Ffmpeg_types::pint8_t __cdecl av_frame_get_qp_table(pAVFrame f, Ffmpeg_types::pint stride, Ffmpeg_types::pint _type);
extern "C" int __cdecl av_frame_set_qp_table(pAVFrame f, pAVBufferRef buf, int stride, int _type);
extern "C" AVColorSpace __cdecl av_frame_get_colorspace(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_colorspace(pAVFrame frame, AVColorSpace val);
extern "C" AVColorRange __cdecl av_frame_get_color_range(const pAVFrame frame);
extern "C" void __cdecl av_frame_set_color_range(pAVFrame frame, AVColorRange val);
extern "C" char * __cdecl av_get_colorspace_name(AVColorSpace val);
extern "C" pAVFrame __cdecl av_frame_alloc(void);
extern "C" void __cdecl av_frame_free(pAVFrame &frame);
extern "C" int __cdecl av_frame_ref(pAVFrame dst, const pAVFrame src);
extern "C" pAVFrame __cdecl av_frame_clone(const pAVFrame src);
extern "C" void __cdecl av_frame_unref(pAVFrame frame);
extern "C" void __cdecl av_frame_move_ref(pAVFrame dst, pAVFrame src);
extern "C" int __cdecl av_frame_get_buffer(pAVFrame frame, int align);
extern "C" int __cdecl av_frame_is_writable(pAVFrame frame);
extern "C" int __cdecl av_frame_make_writable(pAVFrame frame);
extern "C" int __cdecl av_frame_copy(pAVFrame dst, const pAVFrame src);
extern "C" int __cdecl av_frame_copy_props(pAVFrame dst, const pAVFrame src);
extern "C" pAVBufferRef __cdecl av_frame_get_plane_buffer(pAVFrame frame, int plane);
extern "C" pAVFrameSideData __cdecl av_frame_new_side_data(const AVFrame frame, AVFrameSideDataType _type, int size);
extern "C" pAVFrameSideData __cdecl av_frame_new_side_data_from_buf(pAVFrame frame, AVFrameSideDataType _type, pAVBufferRef buf);
extern "C" pAVFrameSideData __cdecl av_frame_get_side_data(const pAVFrame frame, AVFrameSideDataType _type);
extern "C" void __cdecl av_frame_remove_side_data(pAVFrame frame, AVFrameSideDataType _type);
static const System::Int8 AV_FRAME_CROP_UNALIGNED = System::Int8(0x1);
extern "C" int __cdecl av_frame_apply_cropping(pAVFrame frame, int flags);
extern "C" char * __cdecl av_frame_side_data_name(AVFrameSideDataType _type);
static const System::Int8 AV_OPT_FLAG_ENCODING_PARAM = System::Int8(0x1);
static const System::Int8 AV_OPT_FLAG_DECODING_PARAM = System::Int8(0x2);
static const System::Int8 AV_OPT_FLAG_AUDIO_PARAM = System::Int8(0x8);
static const System::Int8 AV_OPT_FLAG_VIDEO_PARAM = System::Int8(0x10);
static const System::Int8 AV_OPT_FLAG_SUBTITLE_PARAM = System::Int8(0x20);
static const System::Int8 AV_OPT_FLAG_EXPORT = System::Int8(0x40);
static const System::Byte AV_OPT_FLAG_READONLY = System::Byte(0x80);
static const System::Word AV_OPT_FLAG_BSF_PARAM = System::Word(0x100);
static const int AV_OPT_FLAG_FILTERING_PARAM = int(0x10000);
static const System::Int8 AV_LOG_QUIET = System::Int8(-8);
static const System::Int8 AV_LOG_PANIC = System::Int8(0x0);
static const System::Int8 AV_LOG_FATAL = System::Int8(0x8);
static const System::Int8 AV_LOG_ERROR = System::Int8(0x10);
static const System::Int8 AV_LOG_WARNING = System::Int8(0x18);
static const System::Int8 AV_LOG_INFO = System::Int8(0x20);
static const System::Int8 AV_LOG_VERBOSE = System::Int8(0x28);
static const System::Int8 AV_LOG_DEBUG = System::Int8(0x30);
static const System::Int8 AV_LOG_TRACE = System::Int8(0x38);
static const System::Int8 AV_LOG_MAX_OFFSET = System::Int8(0x40);
extern "C" char * __cdecl av_get_sample_fmt_name(AVSampleFormat sample_fmt);
extern "C" AVSampleFormat __cdecl av_get_sample_fmt(const char * name);
extern "C" AVSampleFormat __cdecl av_get_alt_sample_fmt(AVSampleFormat sample_fmt, int planar);
extern "C" AVSampleFormat __cdecl av_get_packed_sample_fmt(AVSampleFormat sample_fmt);
extern "C" AVSampleFormat __cdecl av_get_planar_sample_fmt(AVSampleFormat sample_fmt);
extern "C" char * __cdecl av_get_sample_fmt_string(char * buf, int buf_size, AVSampleFormat sample_fmt);
extern "C" int __cdecl av_get_bytes_per_sample(AVSampleFormat sample_fmt);
extern "C" int __cdecl av_sample_fmt_is_planar(AVSampleFormat sample_fmt);
extern "C" int __cdecl av_samples_get_buffer_size(int &linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)/* overload */;
extern "C" int __cdecl av_samples_get_buffer_size(Ffmpeg_types::pint linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align)/* overload */;
extern "C" int __cdecl av_samples_fill_arrays(System::PByte &audio_data, int &linesize, const System::PByte buf, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align);
extern "C" int __cdecl av_samples_alloc(System::PByte &audio_data, Ffmpeg_types::pint linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align);
extern "C" int __cdecl av_samples_alloc_array_and_samples(Ffmpeg_types::ppuint8_t &audio_data, int &linesize, int nb_channels, int nb_samples, AVSampleFormat sample_fmt, int align);
extern "C" int __cdecl av_samples_copy(System::PByte &dst, const Ffmpeg_types::ppuint8_t src, int dst_offset, int src_offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt);
extern "C" int __cdecl av_samples_set_silence(System::PByte &audio_data, int offset, int nb_samples, int nb_channels, AVSampleFormat sample_fmt);
extern "C" int __cdecl av_opt_show2(void * obj, void * av_log_obj, int req_flags, int rej_flags);
extern "C" void __cdecl av_opt_set_defaults(void * s);
extern "C" void __cdecl av_opt_set_defaults2(void * s, int mask, int flags);
extern "C" int __cdecl av_set_options_string(void * ctx, const char * opts, const char * key_val_sep, const char * pairs_sep);
extern "C" int __cdecl av_opt_set_from_string(void * ctx, const char * opts, const System::PPAnsiChar shorthand, const char * key_val_sep, const char * pairs_sep);
extern "C" void __cdecl av_opt_free(void * obj);
extern "C" int __cdecl av_opt_flag_is_set(void * obj, const char * field_name, const char * flag_name);
extern "C" int __cdecl av_opt_set_dict(void * obj, pAVDictionary &options);
extern "C" int __cdecl av_opt_set_dict2(void * obj, pAVDictionary &options, int search_flags);
extern "C" int __cdecl av_opt_get_key_value(const System::PPAnsiChar ropts, const char * key_val_sep, const char * pairs_sep, unsigned flags, System::PPAnsiChar rkey, System::PPAnsiChar rval);
static const System::Int8 AV_OPT_FLAG_IMPLICIT_KEY = System::Int8(0x1);
extern "C" int __cdecl av_opt_eval_flags(void * obj, const pAVOption o, const char * val, int &flags_out);
static const System::Int8 AV_OPT_SEARCH_CHILDREN = System::Int8(0x1);
static const System::Int8 AV_OPT_SEARCH_FAKE_OBJ = System::Int8(0x2);
static const System::Int8 AV_OPT_ALLOW_NULL = System::Int8(0x4);
static const System::Word AV_OPT_MULTI_COMPONENT_RANGE = System::Word(0x1000);
extern "C" pAVOption __cdecl av_opt_find(void * obj, const char * name, const char * _unit, int opt_flags, int search_flags);
extern "C" pAVOption __cdecl av_opt_find2(void * obj, const char * name, const char * _unit, int opt_flags, int search_flags, void * &target_obj);
extern "C" pAVOption __cdecl av_opt_next(const void * obj, const pAVOption prev);
extern "C" void * __cdecl av_opt_child_next(void * obj, void * prev);
extern "C" pAVClass __cdecl av_opt_child_class_next(const pAVClass parent, const pAVClass prev);
extern "C" int __cdecl av_opt_set(void * obj, const char * name, const char * val, int search_flags);
extern "C" int __cdecl av_opt_set_int(void * obj, const char * name, __int64 val, int search_flags);
extern "C" int __cdecl av_opt_set_double(void * obj, const char * name, double val, int search_flags);
extern "C" int __cdecl av_opt_set_q(void * obj, const char * name, const AVRational val, int search_flags);
extern "C" int __cdecl av_opt_set_bin(void * obj, const char * name, const System::PByte val, int size, int search_flags);
extern "C" int __cdecl av_opt_set_image_size(void * obj, const char * name, int w, int h, int search_flags);
extern "C" int __cdecl av_opt_set_pixel_fmt(void * obj, const char * name, AVPixelFormat fmt, int search_flags);
extern "C" int __cdecl av_opt_set_sample_fmt(void * obj, const char * name, AVSampleFormat fmt, int search_flags);
extern "C" int __cdecl av_opt_set_video_rate(void * obj, const char * name, const AVRational val, int search_flags);
extern "C" int __cdecl av_opt_set_channel_layout(void * obj, const char * name, __int64 ch_layout, int search_flags);
extern "C" int __cdecl av_opt_set_dict_val(void * obj, const char * name, const pAVDictionary val, int search_flags);
extern "C" int __cdecl av_opt_get(void * obj, const char * name, int search_flags, System::PByte &out_val);
extern "C" int __cdecl av_opt_get_int(void * obj, const char * name, int search_flags, __int64 &out_val);
extern "C" int __cdecl av_opt_get_double(void * obj, const char * name, int search_flags, double out_val);
extern "C" int __cdecl av_opt_get_q(void * obj, const char * name, int search_flags, AVRational &out_val);
extern "C" int __cdecl av_opt_get_image_size(void * obj, const char * name, int search_flags, int &w_out, int &h_out);
extern "C" int __cdecl av_opt_get_pixel_fmt(void * obj, const char * name, int search_flags, AVPixelFormat &out_fmt);
extern "C" int __cdecl av_opt_get_sample_fmt(void * obj, const char * name, int search_flags, AVSampleFormat &out_fmt);
extern "C" int __cdecl av_opt_get_video_rate(void * obj, const char * name, int search_flags, AVRational &out_val);
extern "C" int __cdecl av_opt_get_channel_layout(void * obj, const char * name, int search_flags, __int64 &ch_layout);
extern "C" int __cdecl av_opt_get_dict_val(void * obj, const char * name, int search_flags, pAVDictionary &out_val);
extern "C" void * __cdecl av_opt_ptr(const pAVClass avclass, void * obj, const char * name);
extern "C" void __cdecl av_opt_freep_ranges(pAVOptionRanges &ranges);
extern "C" int __cdecl av_opt_query_ranges(pAVOptionRanges &ranges, void * obj, const char * key, int flags);
extern "C" int __cdecl av_opt_copy(void * dest, const void * src);
extern "C" int __cdecl av_opt_query_ranges_default(pAVOptionRanges &ranges, void * obj, const char * key, int flags);
extern "C" int __cdecl av_opt_is_set_to_default(void * obj, const pAVOption o);
extern "C" int __cdecl av_opt_is_set_to_default_by_name(void * obj, const char * name, int search_flags);
static const System::Int8 AV_OPT_SERIALIZE_SKIP_DEFAULTS = System::Int8(0x1);
static const System::Int8 AV_OPT_SERIALIZE_OPT_FLAGS_EXACT = System::Int8(0x2);
extern "C" int __cdecl av_opt_serialize(void * obj, int opt_flags, int flags, char * &buffer, const char key_val_sep, const char pairs_sep);
extern "C" void __cdecl av_log(void * avcl, int level, const char * fmt);
extern "C" void __cdecl av_vlog(void * avcl, int level, const char * fmt, PVA_LIST vl);
extern "C" int __cdecl av_log_get_level(void);
extern "C" void __cdecl av_log_set_level(int level);
extern "C" void __cdecl av_log_set_callback(Tav_log_callback callbackproc);
extern "C" void __cdecl av_log_default_callback(void * avcl, int level, const char * fmt, PVA_LIST vl);
extern "C" char * __cdecl av_default_item_name(void * ctx);
extern "C" AVClassCategory __cdecl av_default_get_category(void * ptr);
extern "C" void __cdecl av_log_format_line(void * ptr, int level, const char * fmt, PVA_LIST vl, char * line, int line_size, int &print_prefix);
extern "C" int __cdecl av_log_format_line2(void * ptr, int level, const char * fmt, PVA_LIST vl, char * line, int line_size, int &print_prefix);
static const System::Int8 AV_LOG_SKIP_REPEATED = System::Int8(0x1);
static const System::Int8 AV_LOG_PRINT_LEVEL = System::Int8(0x2);
extern "C" void __cdecl av_log_set_flags(int arg);
extern "C" int __cdecl av_log_get_flags(void);
extern "C" unsigned __cdecl avutil_version(void);
extern "C" char * __cdecl av_version_info(void);
extern "C" char * __cdecl avutil_configuration(void);
extern "C" char * __cdecl avutil_license(void);
extern "C" char * __cdecl av_get_media_type_string(AVMediaType media_type);
extern "C" char __cdecl av_get_picture_type_char(AVPictureType pict_type);
extern "C" unsigned __cdecl av_int_list_length_for_size(unsigned elsize, const void * list, unsigned __int64 term);
extern "C" Ffmpeg_types::PFile __cdecl av_fopen_utf8(const char * path, const char * mode);
extern "C" AVRational __cdecl av_get_time_base_q(void);
static const System::Int8 AV_FOURCC_MAX_STRING_SIZE = System::Int8(0x20);
extern "C" char * __cdecl av_fourcc_make_string(char * buf, unsigned fourcc);
extern "C" int __cdecl av_file_map(const char * filename, System::PByte &bufptr, NativeUInt &size, int log_offset, void * log_ctx);
extern "C" void __cdecl av_file_unmap(System::PByte bufptr, NativeUInt size);
extern "C" int __cdecl av_tempfile(const char * prefix, char * &filename, int log_offset, void * log_ctx);
static const int AVERROR_BSF_NOT_FOUND = int(-1179861752);
static const int AVERROR_BUG = int(-558323010);
static const int AVERROR_BUFFER_TOO_SMALL = int(-1397118274);
static const int AVERROR_DECODER_NOT_FOUND = int(-1128613112);
static const int AVERROR_DEMUXER_NOT_FOUND = int(-1296385272);
static const int AVERROR_ENCODER_NOT_FOUND = int(-1129203192);
static const int AVERROR_EOF = int(-541478725);
static const int AVERROR_EXIT = int(-1414092869);
static const int AVERROR_EXTERNAL = int(-542398533);
static const int AVERROR_FILTER_NOT_FOUND = int(-1279870712);
static const int AVERROR_INVALIDDATA = int(-1094995529);
static const int AVERROR_MUXER_NOT_FOUND = int(-1481985528);
static const int AVERROR_OPTION_NOT_FOUND = int(-1414549496);
static const int AVERROR_PATCHWELCOME = int(-1163346256);
static const int AVERROR_PROTOCOL_NOT_FOUND = int(-1330794744);
static const int AVERROR_STREAM_NOT_FOUND = int(-1381258232);
static const int AVERROR_BUG2 = int(-541545794);
static const int AVERROR_UNKNOWN = int(-1313558101);
static const int AVERROR_EXPERIMENTAL = int(-733130664);
static const int AVERROR_INPUT_CHANGED = int(-1668179713);
static const int AVERROR_OUTPUT_CHANGED = int(-1668179714);
static const int AVERROR_HTTP_BAD_REQUEST = int(-808465656);
static const int AVERROR_HTTP_UNAUTHORIZED = int(-825242872);
static const int AVERROR_HTTP_FORBIDDEN = int(-858797304);
static const int AVERROR_HTTP_NOT_FOUND = int(-875574520);
static const int AVERROR_HTTP_OTHER_4XX = int(-1482175736);
static const int AVERROR_HTTP_SERVER_ERROR = int(-1482175992);
static const System::Int8 AV_ERROR_MAX_STRING_SIZE = System::Int8(0x40);
static const System::Int8 AVERROR_EPERM = System::Int8(-1);
static const System::Int8 AVERROR_ENOENT = System::Int8(-2);
static const System::Int8 AVERROR_ESRCH = System::Int8(-3);
static const System::Int8 AVERROR_EINTR = System::Int8(-4);
static const System::Int8 AVERROR_EIO = System::Int8(-5);
static const System::Int8 AVERROR_ENXIO = System::Int8(-6);
static const System::Int8 AVERROR_E2BIG = System::Int8(-7);
static const System::Int8 AVERROR_ENOEXEC = System::Int8(-8);
static const System::Int8 AVERROR_EBADF = System::Int8(-9);
static const System::Int8 AVERROR_ECHILD = System::Int8(-10);
static const System::Int8 AVERROR_EAGAIN = System::Int8(-11);
static const System::Int8 AVERROR_ENOMEM = System::Int8(-12);
static const System::Int8 AVERROR_EACCES = System::Int8(-13);
static const System::Int8 AVERROR_EFAULT = System::Int8(-14);
static const System::Int8 AVERROR_ENOTBLK = System::Int8(-15);
static const System::Int8 AVERROR_EBUSY = System::Int8(-16);
static const System::Int8 AVERROR_EEXIST = System::Int8(-17);
static const System::Int8 AVERROR_EXDEV = System::Int8(-18);
static const System::Int8 AVERROR_ENODEV = System::Int8(-19);
static const System::Int8 AVERROR_ENOTDIR = System::Int8(-20);
static const System::Int8 AVERROR_EISDIR = System::Int8(-21);
static const System::Int8 AVERROR_EINVAL = System::Int8(-22);
static const System::Int8 AVERROR_ENFILE = System::Int8(-23);
static const System::Int8 AVERROR_EMFILE = System::Int8(-24);
static const System::Int8 AVERROR_ENOTTY = System::Int8(-25);
static const System::Int8 AVERROR_ETXTBSY = System::Int8(-26);
static const System::Int8 AVERROR_EFBIG = System::Int8(-27);
static const System::Int8 AVERROR_ENOSPC = System::Int8(-28);
static const System::Int8 AVERROR_ESPIPE = System::Int8(-29);
static const System::Int8 AVERROR_EROFS = System::Int8(-30);
static const System::Int8 AVERROR_EMLINK = System::Int8(-31);
static const System::Int8 AVERROR_EPIPE = System::Int8(-32);
static const System::Int8 AVERROR_EDOM = System::Int8(-33);
static const System::Int8 AVERROR_ERANGE = System::Int8(-34);
static const System::Int8 AVERROR_EDEADLK = System::Int8(-36);
static const System::Int8 AVERROR_ENAMETOOLONG = System::Int8(-38);
static const System::Int8 AVERROR_ENOLCK = System::Int8(-39);
static const System::Int8 AVERROR_ENOSYS = System::Int8(-40);
static const System::Int8 AVERROR_ENOTEMPTY = System::Int8(-41);
static const System::Int8 AVERROR_ELOOP = System::Int8(-114);
static const System::Int8 AVERROR_ENOMSG = System::Int8(-91);
static const System::Int8 AVERROR_EIDRM = System::Int8(-90);
static const System::Int8 AVERROR_ENOSTR = System::Int8(-99);
static const System::Int8 AVERROR_ENODATA = System::Int8(-96);
static const System::Int8 AVERROR_ETIME = System::Int8(-101);
static const System::Int8 AVERROR_ENOSR = System::Int8(-98);
static const System::Int8 AVERROR_EREMOTE = System::Int8(-71);
static const System::Int8 AVERROR_ENOLINK = System::Int8(-97);
static const System::Int8 AVERROR_EMULTIHOP = System::Int8(-95);
static const System::Int8 AVERROR_EBADMSG = System::Int8(-94);
static const short AVERROR_EPROTO = short(-134);
static const short AVERROR_EOVERFLOW = short(-132);
static const System::Int8 AVERROR_EILSEQ = System::Int8(-42);
static const System::Int8 AVERROR_EUSERS = System::Int8(-68);
static const System::Int8 AVERROR_ENOTSOCK = System::Int8(-128);
static const System::Int8 AVERROR_EDESTADDRREQ = System::Int8(-109);
static const System::Int8 AVERROR_EMSGSIZE = System::Int8(-115);
static const short AVERROR_EPROTOTYPE = short(-136);
static const System::Int8 AVERROR_ENOPROTOOPT = System::Int8(-123);
static const short AVERROR_EPROTONOSUPPORT = short(-135);
static const System::Int8 AVERROR_ESOCKTNOSUPPORT = System::Int8(-44);
static const short AVERROR_EOPNOTSUPP = short(-130);
static const System::Int8 AVERROR_EPFNOSUPPORT = System::Int8(-46);
static const System::Int8 AVERROR_EAFNOSUPPORT = System::Int8(-102);
static const System::Int8 AVERROR_EADDRINUSE = System::Int8(-100);
static const System::Int8 AVERROR_EADDRNOTAVAIL = System::Int8(-101);
static const System::Int8 AVERROR_ENETDOWN = System::Int8(-116);
static const System::Int8 AVERROR_ENETUNREACH = System::Int8(-118);
static const System::Int8 AVERROR_ENETRESET = System::Int8(-117);
static const System::Int8 AVERROR_ECONNABORTED = System::Int8(-106);
static const System::Int8 AVERROR_ECONNRESET = System::Int8(-108);
static const System::Int8 AVERROR_ENOBUFS = System::Int8(-119);
static const System::Int8 AVERROR_EISCONN = System::Int8(-113);
static const System::Int8 AVERROR_ENOTCONN = System::Int8(-126);
static const System::Int8 AVERROR_ESHUTDOWN = System::Int8(-58);
static const System::Int8 AVERROR_ETOOMANYREFS = System::Int8(-59);
static const short AVERROR_ETIMEDOUT = short(-138);
static const System::Int8 AVERROR_ECONNREFUSED = System::Int8(-107);
static const System::Int8 AVERROR_EHOSTDOWN = System::Int8(-64);
static const System::Int8 AVERROR_EHOSTUNREACH = System::Int8(-110);
static const System::Int8 AVERROR_EALREADY = System::Int8(-103);
static const System::Int8 AVERROR_EINPROGRESS = System::Int8(-112);
static const System::Int8 AVERROR_ESTALE = System::Int8(-70);
static const System::Int8 AVERROR_ECANCELED = System::Int8(-105);
static const short AVERROR_EOWNERDEAD = short(-133);
static const System::Int8 AVERROR_ENOTRECOVERABLE = System::Int8(-44);
extern DELPHI_PACKAGE Libavutil__1 CErrorList;
extern "C" int __cdecl av_strerror(int errnum, char * errbuf, NativeUInt errbuf_size);
static const unsigned AV_CPU_FLAG_FORCE = unsigned(0x80000000);
static const System::Int8 AV_CPU_FLAG_MMX = System::Int8(0x1);
static const System::Int8 AV_CPU_FLAG_MMXEXT = System::Int8(0x2);
static const System::Int8 AV_CPU_FLAG_MMX2 = System::Int8(0x2);
static const System::Int8 AV_CPU_FLAG_3DNOW = System::Int8(0x4);
static const System::Int8 AV_CPU_FLAG_SSE = System::Int8(0x8);
static const System::Int8 AV_CPU_FLAG_SSE2 = System::Int8(0x10);
static const int AV_CPU_FLAG_SSE2SLOW = int(0x40000000);
static const System::Int8 AV_CPU_FLAG_3DNOWEXT = System::Int8(0x20);
static const System::Int8 AV_CPU_FLAG_SSE3 = System::Int8(0x40);
static const int AV_CPU_FLAG_SSE3SLOW = int(0x20000000);
static const System::Byte AV_CPU_FLAG_SSSE3 = System::Byte(0x80);
static const int AV_CPU_FLAG_SSSE3SLOW = int(0x4000000);
static const int AV_CPU_FLAG_ATOM = int(0x10000000);
static const System::Word AV_CPU_FLAG_SSE4 = System::Word(0x100);
static const System::Word AV_CPU_FLAG_SSE42 = System::Word(0x200);
static const int AV_CPU_FLAG_AESNI = int(0x80000);
static const System::Word AV_CPU_FLAG_AVX = System::Word(0x4000);
static const int AV_CPU_FLAG_AVXSLOW = int(0x8000000);
static const System::Word AV_CPU_FLAG_XOP = System::Word(0x400);
static const System::Word AV_CPU_FLAG_FMA4 = System::Word(0x800);
static const System::Word AV_CPU_FLAG_CMOV = System::Word(0x1000);
static const System::Word AV_CPU_FLAG_AVX2 = System::Word(0x8000);
static const int AV_CPU_FLAG_FMA3 = int(0x10000);
static const int AV_CPU_FLAG_BMI1 = int(0x20000);
static const int AV_CPU_FLAG_BMI2 = int(0x40000);
static const int AV_CPU_FLAG_AVX512 = int(0x100000);
static const System::Int8 AV_CPU_FLAG_ALTIVEC = System::Int8(0x1);
static const System::Int8 AV_CPU_FLAG_VSX = System::Int8(0x2);
static const System::Int8 AV_CPU_FLAG_POWER8 = System::Int8(0x4);
static const System::Int8 AV_CPU_FLAG_ARMV5TE = System::Int8(0x1);
static const System::Int8 AV_CPU_FLAG_ARMV6 = System::Int8(0x2);
static const System::Int8 AV_CPU_FLAG_ARMV6T2 = System::Int8(0x4);
static const System::Int8 AV_CPU_FLAG_VFP = System::Int8(0x8);
static const System::Int8 AV_CPU_FLAG_VFPV3 = System::Int8(0x10);
static const System::Int8 AV_CPU_FLAG_NEON = System::Int8(0x20);
static const System::Int8 AV_CPU_FLAG_ARMV8 = System::Int8(0x40);
static const System::Byte AV_CPU_FLAG_VFP_VM = System::Byte(0x80);
static const int AV_CPU_FLAG_SETEND = int(0x10000);
extern "C" int __cdecl av_get_cpu_flags(void);
extern "C" void __cdecl av_force_cpu_flags(int flags);
extern "C" void __cdecl av_set_cpu_flags_mask _DEPRECATED_ATTRIBUTE1("Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible") (int mask);
extern "C" int __cdecl av_parse_cpu_flags _DEPRECATED_ATTRIBUTE1("Please use av_parse_cpu_caps() when possible") (const char * s);
extern "C" int __cdecl av_parse_cpu_caps(unsigned &flags, const char * s);
extern "C" int __cdecl av_cpu_count(void);
extern "C" NativeUInt __cdecl av_cpu_max_align(void);
extern "C" void __cdecl av_audio_fifo_free(pAVAudioFifo af);
extern "C" pAVAudioFifo __cdecl av_audio_fifo_alloc(AVSampleFormat sample_fmt, int channels, int nb_samples);
extern "C" int __cdecl av_audio_fifo_realloc(pAVAudioFifo af, int nb_samples);
extern "C" int __cdecl av_audio_fifo_write(pAVAudioFifo af, System::PByte &data, int nb_samples);
extern "C" int __cdecl av_audio_fifo_peek(pAVAudioFifo af, System::PByte &data, int nb_samples);
extern "C" int __cdecl av_audio_fifo_peek_at(pAVAudioFifo af, void * &data, int nb_samples, int offset);
extern "C" int __cdecl av_audio_fifo_read(pAVAudioFifo af, void * &data, int nb_samples);
extern "C" int __cdecl av_audio_fifo_drain(pAVAudioFifo af, int nb_samples);
extern "C" void __cdecl av_audio_fifo_reset(pAVAudioFifo af);
extern "C" int __cdecl av_audio_fifo_size(pAVAudioFifo af);
extern "C" int __cdecl av_audio_fifo_space(pAVAudioFifo af);
extern "C" int __cdecl av_strstart(const char * str, const char * pfx, const System::PPAnsiChar ptr);
extern "C" int __cdecl av_stristart(const char * str, const char * pfx, const System::PPAnsiChar ptr);
extern "C" char * __cdecl av_stristr(const char * haystack, const char * needle);
extern "C" char * __cdecl av_strnstr(const char * haystack, const char * needle, NativeUInt hay_length);
extern "C" NativeUInt __cdecl av_strlcpy(char * dst, const char * src, NativeUInt size);
extern "C" NativeUInt __cdecl av_strlcat(char * dst, const char * src, NativeUInt size);
extern "C" char * __cdecl av_d2str(double d);
extern "C" char * __cdecl av_get_token(const System::PPAnsiChar buf, const char * term);
extern "C" char * __cdecl av_strtok(char * s, const char * delim, System::PPAnsiChar saveptr);
extern "C" int __cdecl av_strcasecmp(const char * a, const char * b);
extern "C" int __cdecl av_strncasecmp(const char * a, const char * b, NativeUInt n);
extern "C" char * __cdecl av_strireplace(const char * str, const char * from, const char * _to);
extern "C" char * __cdecl av_basename(const char * path);
extern "C" char * __cdecl av_dirname(char * path);
extern "C" int __cdecl av_match_name(const char * name, const char * names);
extern "C" char * __cdecl av_append_path_component(const char * path, const char * component);
static const System::Int8 AV_ESCAPE_FLAG_WHITESPACE = System::Int8(0x1);
static const System::Int8 AV_ESCAPE_FLAG_STRICT = System::Int8(0x2);
extern "C" int __cdecl av_escape(char * &dst, const char * src, const char * special_chars, AVEscapeMode mode, int flags);
static const System::Int8 AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES = System::Int8(0x1);
static const System::Int8 AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS = System::Int8(0x2);
static const System::Int8 AV_UTF8_FLAG_ACCEPT_SURROGATES = System::Int8(0x4);
static const System::Int8 AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES = System::Int8(0x8);
static const System::Int8 AV_UTF8_FLAG_ACCEPT_ALL = System::Int8(0x7);
extern "C" int __cdecl av_utf8_decode(int &codep, const Ffmpeg_types::ppuint8_t bufp, const System::PByte buf_end, unsigned flags);
extern "C" int __cdecl av_match_list(const char * name, const char * list, char separator);
static const System::Word AV_BPRINT_SIZE_UNLIMITED = System::Word(0xfffe);
static const System::Int8 AV_BPRINT_SIZE_AUTOMATIC = System::Int8(0x1);
static const System::Int8 AV_BPRINT_SIZE_COUNT_ONLY = System::Int8(0x0);
extern "C" void __cdecl av_bprint_init(pAVBPrint buf, unsigned size_init, unsigned size_max);
extern "C" void __cdecl av_bprint_init_for_buffer(pAVBPrint buf, char * buffer, unsigned size);
extern "C" void __cdecl av_vbprintf(pAVBPrint buf, const char * fmt, PVA_LIST vl_arg);
extern "C" void __cdecl av_bprint_chars(pAVBPrint buf, char c, unsigned n);
extern "C" void __cdecl av_bprint_append_data(pAVBPrint buf, const char * data, unsigned size);
extern "C" void __cdecl av_bprint_strftime(pAVBPrint buf, const char * fmt, const ptm tm);
extern "C" void __cdecl av_bprint_get_buffer(pAVBPrint buf, unsigned size, System::PByte &mem, unsigned &actual_size);
extern "C" void __cdecl av_bprint_clear(pAVBPrint buf);
extern "C" int __cdecl av_bprint_finalize(pAVBPrint buf, char * &ret_str);
extern "C" void __cdecl av_bprint_escape(pAVBPrint dstbuf, const char * src, const char * special_chars, AVEscapeMode mode, int flags);
extern "C" double __cdecl av_display_rotation_get(const Tav_display_matrix &matrix);
extern "C" void __cdecl av_display_rotation_set(const Tav_display_matrix &matrix, double angle);
extern "C" void __cdecl av_display_matrix_flip(const Tav_display_matrix &matrix, int hflip, int vflip);
extern "C" int __cdecl av_expr_parse_and_eval(double &res, const char * s, System::PPAnsiChar const_names, const System::PDouble const_values, System::PPAnsiChar func1_names, Tav_expr_funcs1 funcs1, System::PPAnsiChar func2_names, Tav_expr_funcs2 funcs2, void * opaque, int log_offset, void * log_ctx);
extern "C" int __cdecl av_expr_parse(pAVExpr &expr, const char * s, System::PPAnsiChar const_names, System::PPAnsiChar func1_names, Tav_expr_funcs1 funcs1, System::PPAnsiChar func2_names, Tav_expr_funcs2 funcs2, int log_offset, void * log_ctx);
extern "C" double __cdecl av_expr_eval(pAVExpr e, const System::PDouble const_values, void * opaque);
extern "C" void __cdecl av_expr_free(pAVExpr e);
extern "C" double __cdecl av_strtod(const char * numstr, char * &tail);
extern "C" pAVFifoBuffer __cdecl av_fifo_alloc(unsigned size);
extern "C" pAVFifoBuffer __cdecl av_fifo_alloc_array(NativeUInt nmemb, NativeUInt size);
extern "C" void __cdecl av_fifo_free(pAVFifoBuffer f);
extern "C" void __cdecl av_fifo_freep(pAVFifoBuffer &f);
extern "C" void __cdecl av_fifo_reset(pAVFifoBuffer f);
extern "C" int __cdecl av_fifo_size(const pAVFifoBuffer f);
extern "C" int __cdecl av_fifo_space(const pAVFifoBuffer f);
extern "C" int __cdecl av_fifo_generic_peek_at(pAVFifoBuffer f, void * dest, int offset, int buf_size, Tav_fifo_proc func);
extern "C" int __cdecl av_fifo_generic_peek(pAVFifoBuffer f, void * dest, int buf_size, Tav_fifo_proc func);
extern "C" int __cdecl av_fifo_generic_read(pAVFifoBuffer f, void * dest, int buf_size, Tav_fifo_proc func);
extern "C" int __cdecl av_fifo_generic_write(pAVFifoBuffer f, void * src, int size, Tav_fifo_func func);
extern "C" int __cdecl av_fifo_realloc2(pAVFifoBuffer f, unsigned size);
extern "C" int __cdecl av_fifo_grow(pAVFifoBuffer f, unsigned additional_space);
extern "C" void __cdecl av_fifo_drain(pAVFifoBuffer f, int size);
extern "C" AVHWDeviceType __cdecl av_hwdevice_find_type_by_name(const char * name);
extern "C" char * __cdecl av_hwdevice_get_type_name(AVHWDeviceType _type);
extern "C" AVHWDeviceType __cdecl av_hwdevice_iterate_types(AVHWDeviceType prev);
extern "C" pAVBufferRef __cdecl av_hwdevice_ctx_alloc(AVHWDeviceType _type);
extern "C" int __cdecl av_hwdevice_ctx_init(pAVBufferRef ref);
extern "C" int __cdecl av_hwdevice_ctx_create(pAVBufferRef &device_ctx, AVHWDeviceType _type, const char * device, pAVDictionary opts, int flags);
extern "C" int __cdecl av_hwdevice_ctx_create_derived(pAVBufferRef &dst_ctx, AVHWDeviceType _type, pAVBufferRef src_ctx, int flags);
extern "C" pAVBufferRef __cdecl av_hwframe_ctx_alloc(pAVBufferRef device_ctx);
extern "C" int __cdecl av_hwframe_ctx_init(pAVBufferRef ref);
extern "C" int __cdecl av_hwframe_get_buffer(pAVBufferRef hwframe_ctx, pAVFrame frame, int flags);
extern "C" int __cdecl av_hwframe_transfer_data(pAVFrame dst, const pAVFrame src, int flags);
extern "C" int __cdecl av_hwframe_transfer_get_formats(pAVBufferRef hwframe_ctx, AVHWFrameTransferDirection dir, pAVPixelFormat &formats, int flags);
extern "C" void * __cdecl av_hwdevice_hwconfig_alloc(pAVBufferRef device_ctx);
extern "C" pAVHWFramesConstraints __cdecl av_hwdevice_get_hwframe_constraints(pAVBufferRef ref, const void * hwconfig);
extern "C" void __cdecl av_hwframe_constraints_free(pAVHWFramesConstraints &constraints);
static const System::Int8 AV_HWFRAME_MAP_READ = System::Int8(0x1);
static const System::Int8 AV_HWFRAME_MAP_WRITE = System::Int8(0x2);
static const System::Int8 AV_HWFRAME_MAP_OVERWRITE = System::Int8(0x4);
static const System::Int8 AV_HWFRAME_MAP_DIRECT = System::Int8(0x8);
extern "C" int __cdecl av_hwframe_map(pAVFrame dst, const pAVFrame src, int flags);
extern "C" int __cdecl av_hwframe_ctx_create_derived(pAVBufferRef &derived_frame_ctx, AVPixelFormat format, pAVBufferRef derived_device_ctx, pAVBufferRef source_frame_ctx, int flags);
static const System::Int8 AV_DRM_MAX_PLANES = System::Int8(0x4);
static const System::Int8 AV_PIX_FMT_FLAG_BE = System::Int8(0x1);
static const System::Int8 AV_PIX_FMT_FLAG_PAL = System::Int8(0x2);
static const System::Int8 AV_PIX_FMT_FLAG_BITSTREAM = System::Int8(0x4);
static const System::Int8 AV_PIX_FMT_FLAG_HWACCEL = System::Int8(0x8);
static const System::Int8 AV_PIX_FMT_FLAG_PLANAR = System::Int8(0x10);
static const System::Int8 AV_PIX_FMT_FLAG_RGB = System::Int8(0x20);
static const System::Int8 AV_PIX_FMT_FLAG_PSEUDOPAL = System::Int8(0x40);
static const System::Byte AV_PIX_FMT_FLAG_ALPHA = System::Byte(0x80);
static const System::Word AV_PIX_FMT_FLAG_BAYER = System::Word(0x100);
static const System::Word AV_PIX_FMT_FLAG_FLOAT = System::Word(0x200);
extern "C" int __cdecl av_get_bits_per_pixel(const pAVPixFmtDescriptor pixdesc);
extern "C" int __cdecl av_get_padded_bits_per_pixel(const pAVPixFmtDescriptor pixdesc);
extern "C" pAVPixFmtDescriptor __cdecl av_pix_fmt_desc_get(AVPixelFormat pix_fmt);
extern "C" pAVPixFmtDescriptor __cdecl av_pix_fmt_desc_next(const pAVPixFmtDescriptor prev);
extern "C" AVPixelFormat __cdecl av_pix_fmt_desc_get_id(const pAVPixFmtDescriptor desc);
extern "C" int __cdecl av_pix_fmt_get_chroma_sub_sample(AVPixelFormat pix_fmt, int &h_shift, int &v_shift);
extern "C" int __cdecl av_pix_fmt_count_planes(AVPixelFormat pix_fmt);
extern "C" char * __cdecl av_color_range_name(AVColorRange range);
extern "C" int __cdecl av_color_range_from_name(const char * name);
extern "C" char * __cdecl av_color_primaries_name(AVColorPrimaries primaries);
extern "C" int __cdecl av_color_primaries_from_name(const char * name);
extern "C" char * __cdecl av_color_transfer_name(AVColorTransferCharacteristic transfer);
extern "C" int __cdecl av_color_transfer_from_name(const char * name);
extern "C" char * __cdecl av_color_space_name(AVColorSpace space);
extern "C" int __cdecl av_color_space_from_name(const char * name);
extern "C" char * __cdecl av_chroma_location_name(AVChromaLocation location);
extern "C" int __cdecl av_chroma_location_from_name(const char * name);
extern "C" AVPixelFormat __cdecl av_get_pix_fmt(const char * name);
extern "C" char * __cdecl av_get_pix_fmt_name(AVPixelFormat pix_fmt);
extern "C" char * __cdecl av_get_pix_fmt_string(char * buf, int buf_size, AVPixelFormat pix_fmt);
extern "C" void __cdecl av_read_image_line2(void * dst, const pav_read_array4_puint8_t data, const pav_read_array4_int linesize, const pAVPixFmtDescriptor desc, int x, int y, int c, int w, int read_pal_component, int dst_element_size);
extern "C" void __cdecl av_read_image_line(Ffmpeg_types::puint16_t dst, const pav_read_array4_puint8_t data, const pav_read_array4_int linesize, const pAVPixFmtDescriptor desc, int x, int y, int c, int w, int read_pal_component);
extern "C" void __cdecl av_write_image_line2(const Ffmpeg_types::puint16_t src, pav_read_array4_puint8_t data, const pav_read_array4_int linesize, const pAVPixFmtDescriptor desc, int x, int y, int c, int w, int src_element_size);
extern "C" void __cdecl av_write_image_line(const Ffmpeg_types::puint16_t src, pav_read_array4_puint8_t data, const pav_read_array4_int linesize, const pAVPixFmtDescriptor desc, int x, int y, int c, int w);
extern "C" AVPixelFormat __cdecl av_pix_fmt_swap_endianness(AVPixelFormat pix_fmt);
static const System::Int8 FF_LOSS_RESOLUTION = System::Int8(0x1);
static const System::Int8 FF_LOSS_DEPTH = System::Int8(0x2);
static const System::Int8 FF_LOSS_COLORSPACE = System::Int8(0x4);
static const System::Int8 FF_LOSS_ALPHA = System::Int8(0x8);
static const System::Int8 FF_LOSS_COLORQUANT = System::Int8(0x10);
static const System::Int8 FF_LOSS_CHROMA = System::Int8(0x20);
extern "C" int __cdecl av_get_pix_fmt_loss(AVPixelFormat dst_pix_fmt, AVPixelFormat src_pix_fmt, int has_alpha);
extern "C" AVPixelFormat __cdecl av_find_best_pix_fmt_of_2(AVPixelFormat dst_pix_fmt1, AVPixelFormat dst_pix_fmt2, AVPixelFormat src_pix_fmt, int has_alpha, int &loss_ptr);
extern "C" void __cdecl av_image_fill_max_pixsteps(pav_image_array4_int max_pixsteps, pav_image_array4_int max_pixstep_comps, const pAVPixFmtDescriptor pixdesc);
extern "C" int __cdecl av_image_get_linesize(AVPixelFormat pix_fmt, int width, int plane);
extern "C" int __cdecl av_image_fill_linesizes(pav_image_array4_int linesizes, AVPixelFormat pix_fmt, int width);
extern "C" int __cdecl av_image_fill_pointers(pav_image_array4_puint8_t data, AVPixelFormat pix_fmt, int height, System::PByte ptr, const pav_image_array4_int linesizes);
extern "C" int __cdecl av_image_alloc(pav_image_array4_puint8_t pointers, pav_image_array4_int linesizes, int w, int h, AVPixelFormat pix_fmt, int align)/* overload */;
extern "C" int __cdecl av_image_alloc(void * pointers, void * linesizes, int w, int h, AVPixelFormat pix_fmt, int align)/* overload */;
extern "C" void __cdecl av_image_copy_plane(System::PByte dst, int dst_linesize, const System::PByte src, int src_linesize, int bytewidth, int height);
extern "C" void __cdecl av_image_copy(pav_image_array4_puint8_t dst_data, pav_image_array4_int dst_linesizes, const pav_image_array4_puint8_t src_data, const pav_image_array4_int src_linesizes, AVPixelFormat pix_fmt, int width, int height);
extern "C" void __cdecl av_image_copy_uc_from(pav_image_array4_puint8_t dst_data, const pav_image_array4_ptrdiff_t dst_linesizes, const pav_image_array4_puint8_t src_data, const pav_image_array4_ptrdiff_t src_linesizes, AVPixelFormat pix_fmt, int width, int height);
extern "C" int __cdecl av_image_fill_arrays(pav_image_array4_puint8_t dst_data, pav_image_array4_int dst_linesize, const System::PByte src, AVPixelFormat pix_fmt, int width, int height, int align);
extern "C" int __cdecl av_image_get_buffer_size(AVPixelFormat pix_fmt, int width, int height, int align);
extern "C" int __cdecl av_image_copy_to_buffer(System::PByte dst, int dst_size, const pav_image_array4_puint8_t src_data, const pav_image_array4_int src_linesize, AVPixelFormat pix_fmt, int width, int height, int align);
extern "C" int __cdecl av_image_check_size(unsigned w, unsigned h, int log_offset, void * log_ctx);
extern "C" int __cdecl av_image_check_size2(unsigned w, unsigned h, __int64 max_pixels, AVPixelFormat pix_fmt, int log_offset, void * log_ctx);
extern "C" int __cdecl av_image_check_sar(unsigned w, unsigned h, const AVRational sar);
extern "C" int __cdecl av_image_fill_black(pav_image_array4_puint8_t dst_data, const pav_image_array4_ptrdiff_t dst_linesize, AVPixelFormat pix_fmt, AVColorRange range, int width, int height);
extern "C" __int64 __cdecl av_gettime(void);
extern "C" __int64 __cdecl av_gettime_relative(void);
extern "C" int __cdecl av_gettime_relative_is_monotonic(void);
extern "C" int __cdecl av_usleep(unsigned usec);
static const System::Int8 AV_TS_MAX_STRING_SIZE = System::Int8(0x20);
extern "C" void * __cdecl av_malloc(NativeUInt size);
extern "C" void * __cdecl av_mallocz(NativeUInt size);
extern "C" void * __cdecl av_malloc_array(NativeUInt nmemb, NativeUInt size);
extern "C" void * __cdecl av_mallocz_array(NativeUInt nmemb, NativeUInt size);
extern "C" void * __cdecl av_calloc(NativeUInt nmemb, NativeUInt size);
extern "C" void * __cdecl av_realloc(void * ptr, NativeUInt size);
extern "C" int __cdecl av_reallocp(void * ptr, NativeUInt size);
extern "C" void * __cdecl av_realloc_f(void * ptr, NativeUInt nelem, NativeUInt elsize);
extern "C" void * __cdecl av_realloc_array(void * ptr, NativeUInt nmemb, NativeUInt size);
extern "C" int __cdecl av_reallocp_array(void * ptr, NativeUInt nmemb, NativeUInt size);
extern "C" void * __cdecl av_fast_realloc(void * ptr, unsigned &size, NativeUInt min_size);
extern "C" void __cdecl av_fast_malloc(void * ptr, unsigned &size, NativeUInt min_size);
extern "C" void __cdecl av_fast_mallocz(void * ptr, unsigned &size, NativeUInt min_size);
extern "C" void __cdecl av_free(void * ptr);
extern "C" void __cdecl av_freep(void * ptr);
extern "C" char * __cdecl av_strdup(const char * s);
extern "C" char * __cdecl av_strndup(const char * s, NativeUInt len);
extern "C" void * __cdecl av_memdup(const void * p, NativeUInt size);
extern "C" void __cdecl av_memcpy_backptr(System::PByte dst, int back, int cnt);
extern "C" void __cdecl av_dynarray_add(void * tab_ptr, int &nb_ptr, void * elem);
extern "C" int __cdecl av_dynarray_add_nofree(void * tab_ptr, int &nb_ptr, void * elem);
extern "C" void * __cdecl av_dynarray2_add(void * &tab_ptr, int &nb_ptr, NativeUInt elem_size, const System::PByte elem_data);
extern "C" void __cdecl av_max_alloc(NativeUInt max);
static const System::Int8 AV_TIMECODE_STR_SIZE = System::Int8(0x17);
extern "C" int __cdecl av_timecode_adjust_ntsc_framenum2(int framenum, int fps);
extern "C" unsigned __cdecl av_timecode_get_smpte_from_framenum(const pAVTimecode tc, int framenum);
extern "C" char * __cdecl av_timecode_make_string(const pAVTimecode tc, char * buf, int framenum);
extern "C" char * __cdecl av_timecode_make_smpte_tc_string(char * buf, unsigned tcsmpte, int prevent_df);
extern "C" char * __cdecl av_timecode_make_mpeg_tc_string(char * buf, unsigned tc25bit);
extern "C" int __cdecl av_timecode_init(pAVTimecode tc, const AVRational rate, int flags, int rame_start, void * log_ctx);
extern "C" int __cdecl av_timecode_init_from_string(pAVTimecode tc, const AVRational rate, const char * str, void * log_ctx);
extern "C" int __cdecl av_timecode_check_frame_rate(const AVRational rate);
static const System::Extended M_E = 2.718282E+00;
static const System::Extended M_LN2 = 6.931472E-01;
static const System::Extended M_LN10 = 2.302585E+00;
static const System::Extended M_LOG2_10 = 3.321928E+00;
static const System::Extended M_PHI = 1.618034E+00;
static const System::Extended M_PI = 3.141593E+00;
static const System::Extended M_PI_2 = 1.570796E+00;
static const System::Extended M_SQRT1_2 = 7.071068E-01;
static const System::Extended M_SQRT2 = 1.414214E+00;
static const System::Int8 AV_ROUND_ZERO = System::Int8(0x0);
static const System::Int8 AV_ROUND_INF = System::Int8(0x1);
static const System::Int8 AV_ROUND_DOWN = System::Int8(0x2);
static const System::Int8 AV_ROUND_UP = System::Int8(0x3);
static const System::Int8 AV_ROUND_NEAR_INF = System::Int8(0x5);
static const System::Word AV_ROUND_PASS_MINMAX = System::Word(0x2000);
extern "C" __int64 __cdecl av_gcd(__int64 a, __int64 b);
extern "C" __int64 __cdecl av_rescale(__int64 a, __int64 b, __int64 c);
extern "C" __int64 __cdecl av_rescale_rnd(__int64 a, __int64 b, __int64 c, int rnd);
extern "C" __int64 __cdecl av_rescale_q(__int64 a, const AVRational bq, const AVRational cq);
extern "C" __int64 __cdecl av_rescale_q_rnd(__int64 a, const AVRational bq, const AVRational cq, int rnd);
extern "C" int __cdecl av_compare_ts(__int64 ts_a, const AVRational tb_a, __int64 ts_b, const AVRational tb_b);
extern "C" __int64 __cdecl av_compare_mod(unsigned __int64 a, unsigned __int64 b, unsigned __int64 _mod);
extern "C" __int64 __cdecl av_rescale_delta(const AVRational in_tb, __int64 in_ts, const AVRational fs_tb, int duration, __int64 &last, const AVRational out_tb);
extern "C" __int64 __cdecl av_add_stable(const AVRational ts_tb, __int64 ts, const AVRational inc_tb, __int64 inc);
extern "C" int __cdecl av_parse_ratio(pAVRational q, const char * str, int max, int log_offset, void * log_ctx);
extern "C" int __cdecl av_parse_video_size(int &width_ptr, int &height_ptr, const char * str);
extern "C" int __cdecl av_parse_video_rate(pAVRational rate, const char * str);
extern "C" int __cdecl av_parse_color(System::PByte rgba_color, const char * color_string, int slen, void * log_ctx);
extern "C" char * __cdecl av_get_known_color_name(int color_idx, const Ffmpeg_types::ppuint8_t rgb);
extern "C" int __cdecl av_parse_time(Ffmpeg_types::pint64_t timeval, const char * timestr, int duration);
extern "C" int __cdecl av_find_info_tag(char * arg, int arg_size, const char * tag1, const char * info);
extern "C" char * __cdecl av_small_strptime(const char * p, const char * fmt, ptm dt);
extern "C" int __cdecl av_timegm(ptm tm);
extern "C" pAVMD5 __cdecl av_md5_alloc(void);
extern "C" void __cdecl av_md5_init(pAVMD5 ctx);
extern "C" void __cdecl av_md5_update(pAVMD5 ctx, const System::PByte src, int len);
extern "C" void __cdecl av_md5_final(pAVMD5 ctx, System::PByte dst);
extern "C" void __cdecl av_md5_sum(System::PByte dst, const System::PByte src, const int len);
extern "C" void __cdecl av_assert0_fpu(void);
extern "C" pAVMasteringDisplayMetadata __cdecl av_mastering_display_metadata_alloc(void);
extern "C" pAVMasteringDisplayMetadata __cdecl av_mastering_display_metadata_create_side_data(pAVFrame frame);
extern "C" pAVContentLightMetadata __cdecl av_content_light_metadata_alloc(NativeUInt &size);
extern "C" pAVContentLightMetadata __cdecl av_content_light_metadata_create_side_data(pAVFrame frame);
extern "C" av_pixelutils_sad_fn __cdecl av_pixelutils_get_sad_fn(int w_bits, int h_bits, int aligned, void * log_ctx);
extern "C" unsigned __cdecl av_get_random_seed(void);
extern "C" pAVAES __cdecl av_aes_alloc(void);
extern "C" int __cdecl av_aes_init(pAVAES a, const System::PByte key, int key_bits, int decrypt);
extern "C" void __cdecl av_aes_crypt(pAVAES a, System::PByte dst, const System::PByte src, int count, System::PByte iv, int decrypt);
extern "C" pAVTWOFISH __cdecl av_twofish_alloc(void);
extern "C" int __cdecl av_twofish_init(pAVTWOFISH ctx, const System::PByte key, int key_bits);
extern "C" void __cdecl av_twofish_crypt(pAVTWOFISH ctx, System::PByte dst, const System::PByte src, int count, System::PByte iv, int decrypt);
extern "C" pAVTEA __cdecl av_tea_alloc(void);
extern "C" void __cdecl av_tea_init(pAVTEA ctx, const System::PByte key, int rounds);
extern "C" void __cdecl av_tea_crypt(pAVTEA ctx, System::PByte dst, const System::PByte src, int count, System::PByte iv, int decrypt);
extern "C" AVPixelFormat __cdecl av_map_videotoolbox_format_to_pixfmt(unsigned cv_fmt);
extern "C" unsigned __cdecl av_map_videotoolbox_format_from_pixfmt(AVPixelFormat pix_fmt);
extern "C" int __cdecl av_tx_init(pAVTXContext &ctx, av_tx_fn tx, AVTXType type, int inv, int len, const void * scale, unsigned __int64 flags);
extern "C" void __cdecl av_tx_uninit(pAVTXContext &ctx);
extern "C" void __cdecl av_lfg_init(pAVLFG c, unsigned seed);
extern "C" int __cdecl av_lfg_init_from_data(pAVLFG c, const System::PByte data, unsigned length);
extern "C" void __cdecl av_bmg_get(pAVLFG lfg, const Tav_bmg_get_arrayofdouble &out);
extern DELPHI_PACKAGE int __fastcall RSHIFT(int a, int b);
extern DELPHI_PACKAGE int __fastcall ROUNDED_DIV(int a, int b);
extern DELPHI_PACKAGE int __fastcall FFUDIV(int a, int b);
extern DELPHI_PACKAGE int __fastcall FFUMOD(int a, int b);
extern DELPHI_PACKAGE int __fastcall FFABS(int a);
extern DELPHI_PACKAGE int __fastcall FFSIGN(int a);
extern DELPHI_PACKAGE int __fastcall FFNABS(int a);
extern DELPHI_PACKAGE bool __fastcall FFDIFFSIGN(int x, int y);
extern DELPHI_PACKAGE int __fastcall FFMAX(int a, int b);
extern DELPHI_PACKAGE int __fastcall av_clip_c(int a, int amin, int amax);
extern DELPHI_PACKAGE __int64 __fastcall av_clip64_c(__int64 a, __int64 amin, __int64 amax);
extern DELPHI_PACKAGE System::Byte __fastcall av_clip_uint8_c(int a);
extern DELPHI_PACKAGE System::Int8 __fastcall av_clip_int8_c(int a);
extern DELPHI_PACKAGE System::Word __fastcall av_clip_uint16_c(int a);
extern DELPHI_PACKAGE short __fastcall av_clip_int16_c(int a);
extern DELPHI_PACKAGE int __fastcall av_clipl_int32_c(__int64 a);
extern DELPHI_PACKAGE int __fastcall av_clip_intp2_c(int a, int p);
extern DELPHI_PACKAGE unsigned __fastcall av_clip_uintp2_c(int a, int p);
extern DELPHI_PACKAGE unsigned __fastcall av_mod_uintp2_c(unsigned a, unsigned p);
extern DELPHI_PACKAGE int __fastcall av_sat_add32_c(int a, int b);
extern DELPHI_PACKAGE int __fastcall av_sat_dadd32_c(int a, int b);
extern DELPHI_PACKAGE int __fastcall av_sat_sub32_c(int a, int b);
extern DELPHI_PACKAGE int __fastcall av_sat_dsub32_c(int a, int b);
extern DELPHI_PACKAGE float __fastcall av_clipf_c(float a, float amin, float amax);
extern DELPHI_PACKAGE double __fastcall av_clipd_c(double a, double amin, double amax);
extern DELPHI_PACKAGE int __fastcall av_ceil_log2_c(int x);
extern DELPHI_PACKAGE int __fastcall av_popcount_c(unsigned x);
extern DELPHI_PACKAGE int __fastcall av_popcount64_c(unsigned __int64 x);
extern DELPHI_PACKAGE int __fastcall av_parity_c(unsigned v);
extern DELPHI_PACKAGE AVRational __fastcall av_make_q(int _num, int _den);
extern DELPHI_PACKAGE int __fastcall av_cmp_q(const AVRational &a, const AVRational &b);
extern DELPHI_PACKAGE double __fastcall av_q2d(const AVRational &a);
extern DELPHI_PACKAGE AVRational __fastcall av_inv_q(const AVRational &q);
extern DELPHI_PACKAGE void * __fastcall av_x_if_null(const void * p, const void * x);
extern DELPHI_PACKAGE int __fastcall av_opt_set_int_list(void * obj, char * name, void * list, int item_size, __int64 term, int flags);
extern DELPHI_PACKAGE int __fastcall av_int_list_length(void * list, int item_size, __int64 term);
extern DELPHI_PACKAGE char * __fastcall av_make_error_string(char * errbuf, NativeUInt errbuf_size, int errnum);
extern DELPHI_PACKAGE char * __fastcall av_err2str(int errnum);
extern DELPHI_PACKAGE NativeUInt __fastcall av_strnlen(const char * s, NativeUInt len);
extern DELPHI_PACKAGE bool __fastcall av_isdigit(int c);
extern DELPHI_PACKAGE bool __fastcall av_isgraph(int c);
extern DELPHI_PACKAGE bool __fastcall av_isspace(int c1);
extern DELPHI_PACKAGE int __fastcall av_toupper(int c1);
extern DELPHI_PACKAGE int __fastcall av_tolower(int c1);
extern DELPHI_PACKAGE bool __fastcall av_isxdigit(int c1);
extern DELPHI_PACKAGE bool __fastcall av_bprint_is_complete(const pAVBPrint buf);
extern DELPHI_PACKAGE System::PByte __fastcall av_fifo_peek2(const pAVFifoBuffer f, int offs);
extern DELPHI_PACKAGE char * __fastcall av_ts_make_string(char * buf, __int64 ts);
extern DELPHI_PACKAGE char * __fastcall av_ts2str(__int64 ts);
extern DELPHI_PACKAGE char * __fastcall av_ts_make_time_string(char * buf, __int64 ts, pAVRational tb);
extern DELPHI_PACKAGE char * __fastcall av_ts2timestr(__int64 ts, pAVRational tb);
extern DELPHI_PACKAGE int __fastcall av_size_mult(NativeUInt a, NativeUInt b, NativeUInt &r);
extern DELPHI_PACKAGE int __fastcall av_parse_ratio_quiet(pAVRational q, const char * str, int max);
extern DELPHI_PACKAGE float __fastcall av_int2float(unsigned i);
extern DELPHI_PACKAGE unsigned __fastcall av_float2int(float f);
extern DELPHI_PACKAGE double __fastcall av_int2double(unsigned __int64 i);
extern DELPHI_PACKAGE unsigned __int64 __fastcall av_double2int(double f);
extern DELPHI_PACKAGE unsigned __fastcall av_lfg_get(pAVLFG c);
extern DELPHI_PACKAGE unsigned __fastcall av_mlfg_get(pAVLFG c);
}	/* namespace Libavutil */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_LIBAVUTIL)
using namespace Libavutil;
#endif
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// LibavutilHPP
